From b8921a157aebb4873c8532b88ef734ff5dd75bda Mon Sep 17 00:00:00 2001 From: Matt Bilker Date: Mon, 8 Jul 2019 09:39:58 +0000 Subject: [PATCH] value: turn the new array implementation on for values read from bytes --- src/lib.rs | 7 ++++ src/to_element/node.rs | 6 ++++ src/to_text_xml/node.rs | 6 ++++ src/value/array.rs | 75 ++++++++++------------------------------- src/value/mod.rs | 19 ++++------- 5 files changed, 44 insertions(+), 69 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index ba6be8d..719f036 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -87,6 +87,13 @@ fn read_node(reader: &mut Reader, def: NodeDefinition) -> Result { 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); diff --git a/src/to_element/node.rs b/src/to_element/node.rs index ade03a9..d194fff 100644 --- a/src/to_element/node.rs +++ b/src/to_element/node.rs @@ -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); diff --git a/src/to_text_xml/node.rs b/src/to_text_xml/node.rs index 535c0a9..4f48736 100644 --- a/src/to_text_xml/node.rs +++ b/src/to_text_xml/node.rs @@ -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()), + }); + }, _ => {}, }; diff --git a/src/value/array.rs b/src/value/array.rs index 32edefc..d2e4fb4 100644 --- a/src/value/array.rs +++ b/src/value/array.rs @@ -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(f: &mut fmt::Formatter, values: &[T]) -> fmt::Result { diff --git a/src/value/mod.rs b/src/value/mod.rs index 0b1fd71..de59b3e 100644 --- a/src/value/mod.rs +++ b/src/value/mod.rs @@ -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()), } }