add Tag::cast_tag to prevent code duplication

Author: phip1611

multiboot2/src/lib.rs

@@ -211,14 +211,14 @@ impl BootInformation {
 
     /// Search for the ELF Sections tag.
     pub fn elf_sections_tag(&self) -> Option<ElfSectionsTag> {
-        self.get_tag(TagType::ElfSections)
+        self.get_tag(TagType::ElfSections.into())
             .map(|tag| unsafe { elf_sections::elf_sections_tag(tag, self.offset) })
     }
 
     /// Search for the Memory map tag.
     pub fn memory_map_tag(&self) -> Option<&MemoryMapTag> {
-        self.get_tag(TagType::Mmap)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const MemoryMapTag) })
+        self.get_tag(TagType::Mmap.into())
+            .map(|tag| tag.cast_tag::<MemoryMapTag>())
     }
 
     /// Get an iterator of all module tags.
@@ -228,80 +228,80 @@ impl BootInformation {
 
     /// Search for the BootLoader name tag.
     pub fn boot_loader_name_tag(&self) -> Option<&BootLoaderNameTag> {
-        self.get_tag(TagType::BootLoaderName)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const BootLoaderNameTag) })
+        self.get_tag(TagType::BootLoaderName.into())
+            .map(|tag| tag.cast_tag::<BootLoaderNameTag>())
     }
 
     /// Search for the Command line tag.
     pub fn command_line_tag(&self) -> Option<&CommandLineTag> {
-        self.get_tag(TagType::Cmdline)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const CommandLineTag) })
+        self.get_tag(TagType::Cmdline.into())
+            .map(|tag| tag.cast_tag::<CommandLineTag>())
     }
 
     /// Search for the VBE framebuffer tag.
     pub fn framebuffer_tag(&self) -> Option<FramebufferTag> {
-        self.get_tag(TagType::Framebuffer)
+        self.get_tag(TagType::Framebuffer.into())
             .map(framebuffer::framebuffer_tag)
     }
 
     /// Search for the EFI 32-bit SDT tag.
     pub fn efi_sdt_32_tag(&self) -> Option<&EFISdt32> {
-        self.get_tag(TagType::Efi32)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const EFISdt32) })
+        self.get_tag(TagType::Efi32.into())
+            .map(|tag| tag.cast_tag::<EFISdt32>())
     }
 
     /// Search for the EFI 64-bit SDT tag.
     pub fn efi_sdt_64_tag(&self) -> Option<&EFISdt64> {
-        self.get_tag(TagType::Efi64)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const EFISdt64) })
+        self.get_tag(TagType::Efi64.into())
+            .map(|tag| tag.cast_tag::<EFISdt64>())
     }
 
     /// Search for the (ACPI 1.0) RSDP tag.
     pub fn rsdp_v1_tag(&self) -> Option<&RsdpV1Tag> {
-        self.get_tag(TagType::AcpiV1)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const RsdpV1Tag) })
+        self.get_tag(TagType::AcpiV1.into())
+            .map(|tag| tag.cast_tag::<RsdpV1Tag>())
     }
 
     /// Search for the (ACPI 2.0 or later) RSDP tag.
     pub fn rsdp_v2_tag(&self) -> Option<&RsdpV2Tag> {
-        self.get_tag(TagType::AcpiV2)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const RsdpV2Tag) })
+        self.get_tag(TagType::AcpiV2.into())
+            .map(|tag| tag.cast_tag::<RsdpV2Tag>())
     }
 
     /// Search for the EFI Memory map tag.
     pub fn efi_memory_map_tag(&self) -> Option<&EFIMemoryMapTag> {
         // If the EFIBootServicesNotExited is present, then we should not use
         // the memory map, as it could still be in use.
-        match self.get_tag(TagType::EfiBs) {
+        match self.get_tag(TagType::EfiBs.into()) {
             Some(_tag) => None,
             None => self
-                .get_tag(TagType::EfiMmap)
-                .map(|tag| unsafe { &*(tag as *const Tag as *const EFIMemoryMapTag) }),
+                .get_tag(TagType::EfiMmap.into())
+                .map(|tag| tag.cast_tag::<EFIMemoryMapTag>()),
         }
     }
 
     /// Search for the EFI 32-bit image handle pointer.
     pub fn efi_32_ih(&self) -> Option<&EFIImageHandle32> {
-        self.get_tag(TagType::Efi32Ih)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const EFIImageHandle32) })
+        self.get_tag(TagType::Efi32Ih.into())
+            .map(|tag| tag.cast_tag::<EFIImageHandle32>())
     }
 
     /// Search for the EFI 64-bit image handle pointer.
     pub fn efi_64_ih(&self) -> Option<&EFIImageHandle64> {
-        self.get_tag(TagType::Efi64Ih)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const EFIImageHandle64) })
+        self.get_tag(TagType::Efi64Ih.into())
+            .map(|tag| tag.cast_tag::<EFIImageHandle64>())
     }
 
     /// Search for the Image Load Base Physical Address.
     pub fn load_base_addr(&self) -> Option<&ImageLoadPhysAddr> {
-        self.get_tag(TagType::LoadBaseAddr)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const ImageLoadPhysAddr) })
+        self.get_tag(TagType::LoadBaseAddr.into())
+            .map(|tag| tag.cast_tag::<ImageLoadPhysAddr>())
     }
 
     /// Search for the VBE information tag.
     pub fn vbe_info_tag(&self) -> Option<&'static VBEInfoTag> {
-        self.get_tag(TagType::Vbe)
-            .map(|tag| unsafe { &*(tag as *const Tag as *const VBEInfoTag) })
+        self.get_tag(TagType::Vbe.into())
+            .map(|tag| tag.cast_tag::<VBEInfoTag>())
     }
 
     fn get(&self) -> &BootInformationInner {

multiboot2/src/tag_type.rs

@@ -114,6 +114,13 @@ pub struct Tag {
     // tag specific fields
 }
 
+impl Tag {
+    /// Casts the base tag to the specific tag type.
+    pub fn cast_tag<'a, T>(&self) -> &'a T {
+        unsafe { &*(self as *const Tag as *const T) }
+    }
+}
+
 impl Debug for Tag {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("Tag")