Leahnaya/kbinxml-rs
1
0
Fork 0
mirror of https://github.com/mbilker/kbinxml-rs.git synced 2026-09-07 18:15:22 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

value: turn the new array implementation on for values read from bytes

Browse Source
This commit is contained in:
Matt Bilker
2019-07-08 09:39:58 +00:00
parent b9e81f0582
commit b8921a157a
5 changed files with 44 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/lib.rs
View File

@@ -87,6 +87,13 @@ fn read_node(reader: &mut Reader, def: NodeDefinition) -> Result<Element> {
debug!("KbinXml::read_node(name: {}) => value: {:?}", elem.name(), value);
elem.append_text_node(value);
},
Value::ArrayNew(values) => {
elem.set_attr("__count", values.len());
let value = values.to_string();
debug!("KbinXml::read_node(name: {}) => value: {:?}", elem.name(), value);
elem.append_text_node(value);
},
value => {
let value = value.to_string();
debug!("KbinXml::read_node(name: {}) => value: {:?}", elem.name(), value);

6
src/to_element/node.rs
View File

@@ -33,6 +33,12 @@ impl ToElement for Node {
let value = Value::array_as_string(values);
elem.append_text_node(value);
},
Value::ArrayNew(values) => {
elem.set_attr("__count", values.len());
let value = value.to_string();
elem.append_text_node(value);
},
value => {
let value = value.to_string();
elem.append_text_node(value);

6
src/to_text_xml/node.rs
View File

@@ -39,6 +39,12 @@ impl ToTextXml for Node {
value: Cow::Owned(values.len().to_string().into_bytes()),
});
},
Value::ArrayNew(ref values) => {
elem.push_attribute(Attribute {
key: b"__count",
value: Cow::Owned(values.len().to_string().into_bytes()),
});
},
_ => {},
};

75
src/value/array.rs
View File

@@ -64,7 +64,7 @@ pub enum ValueArray {
Vb(Vec<[bool; 16]>),
}
macro_rules! tuple {
macro_rules! type_impl {
(
$($konst:ident),*$(,)?
) => {
@@ -119,11 +119,27 @@ macro_rules! tuple {
Ok(())
}
pub fn standard_type(&self) -> StandardType {
match self {
$(
ValueArray::$konst(_) => StandardType::$konst,
)*
}
}
pub fn len(&self) -> usize {
match self {
$(
ValueArray::$konst(values) => values.len(),
)*
}
}
};
}
impl ValueArray {
tuple! {
type_impl! {
S8,
U8,
S16,
@@ -148,61 +164,6 @@ impl ValueArray {
Float2, Float3, Float4,
Double2, Double3, Double4,
}
pub fn standard_type(&self) -> StandardType {
match self {
ValueArray::S8(_) => StandardType::S8,
ValueArray::U8(_) => StandardType::U8,
ValueArray::S16(_) => StandardType::S16,
ValueArray::U16(_) => StandardType::U16,
ValueArray::S32(_) => StandardType::S32,
ValueArray::U32(_) => StandardType::U32,
ValueArray::S64(_) => StandardType::S64,
ValueArray::U64(_) => StandardType::U64,
ValueArray::Ip4(_) => StandardType::Ip4,
ValueArray::Float(_) => StandardType::Float,
ValueArray::Double(_) => StandardType::Double,
ValueArray::S8_2(_) => StandardType::S8_2,
ValueArray::U8_2(_) => StandardType::U8_2,
ValueArray::S16_2(_) => StandardType::S16_2,
ValueArray::U16_2(_) => StandardType::U16_2,
ValueArray::S32_2(_) => StandardType::S32_2,
ValueArray::U32_2(_) => StandardType::U32_2,
ValueArray::S64_2(_) => StandardType::S64_2,
ValueArray::U64_2(_) => StandardType::U64_2,
ValueArray::Float2(_) => StandardType::Float2,
ValueArray::Double2(_) => StandardType::Double2,
ValueArray::S8_3(_) => StandardType::S8_3,
ValueArray::U8_3(_) => StandardType::U8_3,
ValueArray::S16_3(_) => StandardType::S16_3,
ValueArray::U16_3(_) => StandardType::U16_3,
ValueArray::S32_3(_) => StandardType::S32_3,
ValueArray::U32_3(_) => StandardType::U32_3,
ValueArray::S64_3(_) => StandardType::S64_3,
ValueArray::U64_3(_) => StandardType::U64_3,
ValueArray::Float3(_) => StandardType::Float3,
ValueArray::Double3(_) => StandardType::Double3,
ValueArray::S8_4(_) => StandardType::S8_4,
ValueArray::U8_4(_) => StandardType::U8_4,
ValueArray::S16_4(_) => StandardType::S16_4,
ValueArray::U16_4(_) => StandardType::U16_4,
ValueArray::S32_4(_) => StandardType::S32_4,
ValueArray::U32_4(_) => StandardType::U32_4,
ValueArray::S64_4(_) => StandardType::S64_4,
ValueArray::U64_4(_) => StandardType::U64_4,
ValueArray::Float4(_) => StandardType::Float4,
ValueArray::Double4(_) => StandardType::Double4,
ValueArray::Vs8(_) => StandardType::Vs8,
ValueArray::Vu8(_) => StandardType::Vu8,
ValueArray::Vs16(_) => StandardType::Vs16,
ValueArray::Vu16(_) => StandardType::Vu16,
ValueArray::Boolean(_) => StandardType::Boolean,
ValueArray::Boolean2(_) => StandardType::Boolean2,
ValueArray::Boolean3(_) => StandardType::Boolean3,
ValueArray::Boolean4(_) => StandardType::Boolean4,
ValueArray::Vb(_) => StandardType::Vb,
}
}
}
fn write_values<T: fmt::Display>(f: &mut fmt::Formatter, values: &[T]) -> fmt::Result {

19
src/value/mod.rs
View File

@@ -160,18 +160,13 @@ macro_rules! tuple {
let node_size = node_type.size * node_type.count;
if is_array {
let mut values = Vec::new();
for chunk in input.chunks(node_size) {
match Value::from_standard_type(node_type, false, chunk)? {
Some(value) => values.push(value),
None => return Err(KbinErrorKind::InvalidState.into()),
}
}
let value = Value::Array(node_type, values);
let value = match ValueArray::from_standard_type(node_type, input)? {
Some(value) => value,
None => return Err(KbinErrorKind::InvalidState.into()),
};
debug!("Value::from_standard_type({:?}) input: 0x{:02x?} => {:?}", node_type, input, value);
return Ok(Some(value));
return Ok(Some(Value::ArrayNew(value)));
}
match node_type {
@@ -518,9 +513,9 @@ impl Value {
}
}
pub fn as_array(&self) -> Result<&[Value], KbinError> {
pub fn as_array(&self) -> Result<&ValueArray, KbinError> {
match self {
Value::Array(_, ref values) => Ok(values),
Value::ArrayNew(ref values) => Ok(values),
value => Err(KbinErrorKind::ExpectedValueArray(value.clone()).into()),
}
}