1 files changed, 53 insertions, 23 deletions

diff --git a/src/structured_values/volume_name.rs b/src/structured_values/volume_name.rs
index 91ca1a2..ce51386 100644
--- a/src/structured_values/volume_name.rs
+++ b/src/structured_values/volume_name.rs
@@ -4,8 +4,13 @@
 use crate::attribute::NtfsAttributeType;
 use crate::error::{NtfsError, Result};
 use crate::string::NtfsString;
-use crate::structured_values::{NtfsStructuredValue, NtfsStructuredValueFromSlice};
+use crate::structured_values::{
+    NtfsStructuredValue, NtfsStructuredValueFromResidentAttributeValue,
+};
+use crate::value::slice::NtfsSliceValue;
+use crate::value::NtfsValue;
 use arrayvec::ArrayVec;
+use binread::io::{Cursor, Read, Seek};
 use core::mem;
 
 /// The smallest VolumeName attribute has a name containing just a single character.
@@ -20,6 +25,35 @@ pub struct NtfsVolumeName {
 }
 
 impl NtfsVolumeName {
+    fn new<T>(r: &mut T, position: u64, value_length: u64) -> Result<Self>
+    where
+        T: Read + Seek,
+    {
+        if value_length < VOLUME_NAME_MIN_SIZE as u64 {
+            return Err(NtfsError::InvalidStructuredValueSize {
+                position,
+                ty: NtfsAttributeType::VolumeName,
+                expected: VOLUME_NAME_MIN_SIZE as u64,
+                actual: value_length,
+            });
+        } else if value_length > VOLUME_NAME_MAX_SIZE as u64 {
+            return Err(NtfsError::InvalidStructuredValueSize {
+                position,
+                ty: NtfsAttributeType::VolumeName,
+                expected: VOLUME_NAME_MAX_SIZE as u64,
+                actual: value_length,
+            });
+        }
+
+        let value_length = value_length as usize;
+
+        let mut name = ArrayVec::from([0u8; VOLUME_NAME_MAX_SIZE]);
+        r.read_exact(&mut name[..value_length])?;
+        name.truncate(value_length);
+
+        Ok(Self { name })
+    }
+
     /// Gets the file name and returns it wrapped in an [`NtfsString`].
     pub fn name<'s>(&'s self) -> NtfsString<'s> {
         NtfsString(&self.name)
@@ -33,31 +67,27 @@ impl NtfsVolumeName {
     }
 }
 
-impl NtfsStructuredValue for NtfsVolumeName {
+impl<'n, 'f> NtfsStructuredValue<'n, 'f> for NtfsVolumeName {
     const TY: NtfsAttributeType = NtfsAttributeType::VolumeName;
-}
 
-impl<'s> NtfsStructuredValueFromSlice<'s> for NtfsVolumeName {
-    fn from_slice(slice: &'s [u8], position: u64) -> Result<Self> {
-        if slice.len() < VOLUME_NAME_MIN_SIZE {
-            return Err(NtfsError::InvalidStructuredValueSize {
-                position,
-                ty: NtfsAttributeType::VolumeName,
-                expected: VOLUME_NAME_MIN_SIZE,
-                actual: slice.len(),
-            });
-        } else if slice.len() > VOLUME_NAME_MAX_SIZE {
-            return Err(NtfsError::InvalidStructuredValueSize {
-                position,
-                ty: NtfsAttributeType::VolumeName,
-                expected: VOLUME_NAME_MAX_SIZE,
-                actual: slice.len(),
-            });
-        }
+    fn from_value<T>(fs: &mut T, value: NtfsValue<'n, 'f>) -> Result<Self>
+    where
+        T: Read + Seek,
+    {
+        let position = value.data_position().unwrap();
+        let value_length = value.len();
 
-        let mut name = ArrayVec::new();
-        name.try_extend_from_slice(slice).unwrap();
+        let mut value_attached = value.attach(fs);
+        Self::new(&mut value_attached, position, value_length)
+    }
+}
 
-        Ok(Self { name })
+impl<'n, 'f> NtfsStructuredValueFromResidentAttributeValue<'n, 'f> for NtfsVolumeName {
+    fn from_resident_attribute_value(value: NtfsSliceValue<'f>) -> Result<Self> {
+        let position = value.data_position().unwrap();
+        let value_length = value.len();
+
+        let mut cursor = Cursor::new(value.data());
+        Self::new(&mut cursor, position, value_length)
     }
 }