Merge pull request #5559 from JosJuice/discio-rename

DiscIO: Remove C/I/S prefixes from class names

1 files changed, 38 insertions, 38 deletions

diff --git a/Source/Core/DiscIO/VolumeDirectory.cpp b/Source/Core/DiscIO/VolumeDirectory.cpp
index 6abe84d66e..ed965983e6 100644
--- a/Source/Core/DiscIO/VolumeDirectory.cpp
+++ b/Source/Core/DiscIO/VolumeDirectory.cpp
@@ -30,11 +30,11 @@ static u32 ComputeNameSize(const File::FSTEntry& parent_entry);
 static std::string ASCIIToUppercase(std::string str);
 static void ConvertUTF8NamesToSHIFTJIS(File::FSTEntry& parent_entry);
 
-const size_t CVolumeDirectory::MAX_NAME_LENGTH;
-const size_t CVolumeDirectory::MAX_ID_LENGTH;
+const size_t VolumeDirectory::MAX_NAME_LENGTH;
+const size_t VolumeDirectory::MAX_ID_LENGTH;
 
-CVolumeDirectory::CVolumeDirectory(const std::string& directory, bool is_wii,
-                                   const std::string& apploader, const std::string& dol)
+VolumeDirectory::VolumeDirectory(const std::string& directory, bool is_wii,
+                                 const std::string& apploader, const std::string& dol)
     : m_data_start_address(-1), m_disk_header(DISKHEADERINFO_ADDRESS),
       m_disk_header_info(std::make_unique<SDiskHeaderInfo>()), m_fst_address(0), m_dol_address(0)
 {
@@ -56,16 +56,16 @@ CVolumeDirectory::CVolumeDirectory(const std::string& directory, bool is_wii,
   BuildFST();
 }
 
-CVolumeDirectory::~CVolumeDirectory()
+VolumeDirectory::~VolumeDirectory()
 {
 }
 
-bool CVolumeDirectory::IsValidDirectory(const std::string& directory)
+bool VolumeDirectory::IsValidDirectory(const std::string& directory)
 {
   return File::IsDirectory(ExtractDirectoryName(directory));
 }
 
-bool CVolumeDirectory::Read(u64 offset, u64 length, u8* buffer, const Partition& partition) const
+bool VolumeDirectory::Read(u64 offset, u64 length, u8* buffer, const Partition& partition) const
 {
   bool decrypt = partition != PARTITION_NONE;
 
@@ -160,27 +160,27 @@ bool CVolumeDirectory::Read(u64 offset, u64 length, u8* buffer, const Partition&
   return true;
 }
 
-std::vector<Partition> CVolumeDirectory::GetPartitions() const
+std::vector<Partition> VolumeDirectory::GetPartitions() const
 {
   return m_is_wii ? std::vector<Partition>{GetGamePartition()} : std::vector<Partition>();
 }
 
-Partition CVolumeDirectory::GetGamePartition() const
+Partition VolumeDirectory::GetGamePartition() const
 {
   return m_is_wii ? Partition(0x50000) : PARTITION_NONE;
 }
 
-std::string CVolumeDirectory::GetGameID(const Partition& partition) const
+std::string VolumeDirectory::GetGameID(const Partition& partition) const
 {
   return std::string(m_disk_header.begin(), m_disk_header.begin() + MAX_ID_LENGTH);
 }
 
-void CVolumeDirectory::SetGameID(const std::string& id)
+void VolumeDirectory::SetGameID(const std::string& id)
 {
   memcpy(m_disk_header.data(), id.c_str(), std::min(id.length(), MAX_ID_LENGTH));
 }
 
-Region CVolumeDirectory::GetRegion() const
+Region VolumeDirectory::GetRegion() const
 {
   if (m_is_wii)
     return RegionSwitchWii(m_disk_header[3]);
@@ -188,18 +188,18 @@ Region CVolumeDirectory::GetRegion() const
   return RegionSwitchGC(m_disk_header[3]);
 }
 
-Country CVolumeDirectory::GetCountry(const Partition& partition) const
+Country VolumeDirectory::GetCountry(const Partition& partition) const
 {
   return CountrySwitch(m_disk_header[3]);
 }
 
-std::string CVolumeDirectory::GetMakerID(const Partition& partition) const
+std::string VolumeDirectory::GetMakerID(const Partition& partition) const
 {
   // Not implemented
   return "00";
 }
 
-std::string CVolumeDirectory::GetInternalName(const Partition& partition) const
+std::string VolumeDirectory::GetInternalName(const Partition& partition) const
 {
   char name[0x60];
   if (Read(0x20, 0x60, (u8*)name, partition))
@@ -208,7 +208,7 @@ std::string CVolumeDirectory::GetInternalName(const Partition& partition) const
     return "";
 }
 
-std::map<Language, std::string> CVolumeDirectory::GetLongNames() const
+std::map<Language, std::string> VolumeDirectory::GetLongNames() const
 {
   std::string name = GetInternalName();
   if (name.empty())
@@ -216,7 +216,7 @@ std::map<Language, std::string> CVolumeDirectory::GetLongNames() const
   return {{Language::LANGUAGE_UNKNOWN, name}};
 }
 
-std::vector<u32> CVolumeDirectory::GetBanner(int* width, int* height) const
+std::vector<u32> VolumeDirectory::GetBanner(int* width, int* height) const
 {
   // Not implemented
   *width = 0;
@@ -224,25 +224,25 @@ std::vector<u32> CVolumeDirectory::GetBanner(int* width, int* height) const
   return std::vector<u32>();
 }
 
-void CVolumeDirectory::SetName(const std::string& name)
+void VolumeDirectory::SetName(const std::string& name)
 {
   size_t length = std::min(name.length(), MAX_NAME_LENGTH);
   memcpy(&m_disk_header[0x20], name.c_str(), length);
   m_disk_header[length + 0x20] = 0;
 }
 
-std::string CVolumeDirectory::GetApploaderDate(const Partition& partition) const
+std::string VolumeDirectory::GetApploaderDate(const Partition& partition) const
 {
   // Not implemented
   return "VOID";
 }
 
-Platform CVolumeDirectory::GetVolumeType() const
+Platform VolumeDirectory::GetVolumeType() const
 {
   return m_is_wii ? Platform::WII_DISC : Platform::GAMECUBE_DISC;
 }
 
-BlobType CVolumeDirectory::GetBlobType() const
+BlobType VolumeDirectory::GetBlobType() const
 {
   // VolumeDirectory isn't actually a blob, but it sort of acts
   // like one, so it makes sense that it has its own blob type.
@@ -250,19 +250,19 @@ BlobType CVolumeDirectory::GetBlobType() const
   return BlobType::DIRECTORY;
 }
 
-u64 CVolumeDirectory::GetSize() const
+u64 VolumeDirectory::GetSize() const
 {
   // Not implemented
   return 0;
 }
 
-u64 CVolumeDirectory::GetRawSize() const
+u64 VolumeDirectory::GetRawSize() const
 {
   // Not implemented
   return 0;
 }
 
-std::string CVolumeDirectory::ExtractDirectoryName(const std::string& directory)
+std::string VolumeDirectory::ExtractDirectoryName(const std::string& directory)
 {
   std::string result = directory;
 
@@ -287,7 +287,7 @@ std::string CVolumeDirectory::ExtractDirectoryName(const std::string& directory)
   return result;
 }
 
-void CVolumeDirectory::SetDiskTypeWii()
+void VolumeDirectory::SetDiskTypeWii()
 {
   Write32(0x5d1c9ea3, 0x18, &m_disk_header);
   memset(&m_disk_header[0x1c], 0, 4);
@@ -296,7 +296,7 @@ void CVolumeDirectory::SetDiskTypeWii()
   m_address_shift = 2;
 }
 
-void CVolumeDirectory::SetDiskTypeGC()
+void VolumeDirectory::SetDiskTypeGC()
 {
   memset(&m_disk_header[0x18], 0, 4);
   Write32(0xc2339f3d, 0x1c, &m_disk_header);
@@ -305,7 +305,7 @@ void CVolumeDirectory::SetDiskTypeGC()
   m_address_shift = 0;
 }
 
-bool CVolumeDirectory::SetApploader(const std::string& apploader)
+bool VolumeDirectory::SetApploader(const std::string& apploader)
 {
   if (!apploader.empty())
   {
@@ -338,7 +338,7 @@ bool CVolumeDirectory::SetApploader(const std::string& apploader)
   }
 }
 
-void CVolumeDirectory::SetDOL(const std::string& dol)
+void VolumeDirectory::SetDOL(const std::string& dol)
 {
   if (!dol.empty())
   {
@@ -354,7 +354,7 @@ void CVolumeDirectory::SetDOL(const std::string& dol)
   }
 }
 
-void CVolumeDirectory::BuildFST()
+void VolumeDirectory::BuildFST()
 {
   m_fst_data.clear();
 
@@ -394,8 +394,8 @@ void CVolumeDirectory::BuildFST()
   Write32((u32)(m_fst_data.size() >> m_address_shift), 0x042c, &m_disk_header);
 }
 
-void CVolumeDirectory::WriteToBuffer(u64 source_start_address, u64 source_length, const u8* source,
-                                     u64* address, u64* length, u8** buffer) const
+void VolumeDirectory::WriteToBuffer(u64 source_start_address, u64 source_length, const u8* source,
+                                    u64* address, u64* length, u8** buffer) const
 {
   if (*length == 0)
     return;
@@ -416,7 +416,7 @@ void CVolumeDirectory::WriteToBuffer(u64 source_start_address, u64 source_length
   }
 }
 
-void CVolumeDirectory::PadToAddress(u64 start_address, u64* address, u64* length, u8** buffer) const
+void VolumeDirectory::PadToAddress(u64 start_address, u64* address, u64* length, u8** buffer) const
 {
   if (start_address > *address && *length > 0)
   {
@@ -428,7 +428,7 @@ void CVolumeDirectory::PadToAddress(u64 start_address, u64* address, u64* length
   }
 }
 
-void CVolumeDirectory::Write32(u32 data, u32 offset, std::vector<u8>* const buffer)
+void VolumeDirectory::Write32(u32 data, u32 offset, std::vector<u8>* const buffer)
 {
   (*buffer)[offset++] = (data >> 24);
   (*buffer)[offset++] = (data >> 16) & 0xff;
@@ -436,8 +436,8 @@ void CVolumeDirectory::Write32(u32 data, u32 offset, std::vector<u8>* const buff
   (*buffer)[offset] = (data)&0xff;
 }
 
-void CVolumeDirectory::WriteEntryData(u32* entry_offset, u8 type, u32 name_offset, u64 data_offset,
-                                      u64 length, u32 address_shift)
+void VolumeDirectory::WriteEntryData(u32* entry_offset, u8 type, u32 name_offset, u64 data_offset,
+                                     u64 length, u32 address_shift)
 {
   m_fst_data[(*entry_offset)++] = type;
 
@@ -452,15 +452,15 @@ void CVolumeDirectory::WriteEntryData(u32* entry_offset, u8 type, u32 name_offse
   *entry_offset += 4;
 }
 
-void CVolumeDirectory::WriteEntryName(u32* name_offset, const std::string& name)
+void VolumeDirectory::WriteEntryName(u32* name_offset, const std::string& name)
 {
   strncpy((char*)&m_fst_data[*name_offset + m_fst_name_offset], name.c_str(), name.length() + 1);
 
   *name_offset += (u32)(name.length() + 1);
 }
 
-void CVolumeDirectory::WriteDirectory(const File::FSTEntry& parent_entry, u32* fst_offset,
-                                      u32* name_offset, u64* data_offset, u32 parent_entry_index)
+void VolumeDirectory::WriteDirectory(const File::FSTEntry& parent_entry, u32* fst_offset,
+                                     u32* name_offset, u64* data_offset, u32 parent_entry_index)
 {
   std::vector<File::FSTEntry> sorted_entries = parent_entry.children;