Enum MapKey 

pub enum MapKey {
    None,
    Bool(bool),
    I8(i8),
    U8(u8),
    I16(i16),
    U16(u16),
    I32(i32),
    U32(u32),
    I64(i64),
    U64(u64),
    F32(FloatBits),
    Vector2([FloatBits; 2]),
    Vector3([FloatBits; 3]),
    Vector4([FloatBits; 4]),
    Matrix44([FloatBits; 16]),
    Color(Color<u8>),
    String(String),
    Hash(HashValue),
    File(WadHash),
}

A map key, owned and free of metadata: every kind Kind::is_valid_map_key admits.

Floats are held as their bit patterns. The key is Eq and Hash, and two keys are equal exactly when the file writes the same bytes for them. The variants carry the client’s names for the tags, as Leaf does.

Variants

None

Kind::None.

Bool(bool)

Kind::Bool.

I8(i8)

Kind::I8.

U8(u8)

Kind::U8.

I16(i16)

Kind::I16.

U16(u16)

Kind::U16.

I32(i32)

Kind::I32.

U32(u32)

Kind::U32.

I64(i64)

Kind::I64.

U64(u64)

Kind::U64.

F32(FloatBits)

Kind::F32.

Vector2([FloatBits; 2])

Kind::Vector2.

Vector3([FloatBits; 3])

Kind::Vector3.

Vector4([FloatBits; 4])

Kind::Vector4.

Matrix44([FloatBits; 16])

Kind::Matrix44, row by row as the wire holds it.

Color(Color<u8>)

Kind::Color.

String(String)

Kind::String.

Hash(HashValue)

Kind::Hash. The value includes its stored width.

File(WadHash)

Kind::WadChunkLink.

Implementations

impl MapKey

pub fn from_literal(literal: &KeyLiteral<'_>, kind: Kind) -> Option<Self>

The key a {key} literal selects in a map keyed by kind, or None when the literal does not convert.

The conversion is the one BinObject::resolve applies to a {key} subscript: a number fills an integer or float key, a string is the text of a string key and is hashed for a Hash or WadChunkLink key, and a number is the raw value of a hashed key.

Examples

use ltk_hash::{BinHash, Hash as _};
use ltk_meta::{
    path::{KeyLiteral, MapKey},
    property::Kind,
};

let weapon = KeyLiteral::from("weapon");
assert_eq!(
    MapKey::from_literal(&weapon, Kind::Hash),
    Some(MapKey::Hash(BinHash::hash_str("weapon").into()))
);
assert_eq!(MapKey::from_literal(&weapon, Kind::U32), None);

impl MapKey

pub fn kind(&self) -> Kind

The kind of value this key is.

pub fn from_leaf(leaf: Leaf<'_>) -> Option<Self>

A leaf as a key, or None for a Leaf::Link or a Leaf::Flag. No map is keyed by either.

pub fn to_value(&self) -> PropertyValueEnum

This key as a value of its kind.

Trait Implementations

impl Clone for MapKey

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MapKey

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

Formats the value using the given formatter.

impl Display for MapKey

The key as the text inside a {key} segment of the hash form: an integer in decimal, a float in its shortest round-trip form, a string as a JSON string, a hash as lowercase zero-padded hex, a vector, colour or matrix as its components in parentheses, and None as nothing.

Examples

use ltk_hash::BinHash;
use ltk_meta::path::MapKey;

assert_eq!(MapKey::String("weapon".into()).to_string(), r#""weapon""#);
assert_eq!(MapKey::Hash(BinHash(0x1e6b_a0c4).into()).to_string(), "1e6ba0c4");

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

Formats the value using the given formatter.

impl Eq for MapKey

impl Hash for MapKey

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 PartialEq for MapKey

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for MapKey

impl TryFrom<&PropertyValueEnum> for MapKey

Every kind Kind::is_valid_map_key admits converts. Metadata is dropped.

Errors

Error::InvalidKeyType for a kind no map is keyed by.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &PropertyValueEnum) -> Result<Self, Error>

Performs the conversion.