Merge pull request #13117 from mitaclaw/ranges-modernization-9-trivial-find

Ranges Algorithms Modernization - Find

Source/Core/Common/IniFile.cpp

@@ -85,7 +85,7 @@ bool IniFile::Section::Delete(std::string_view key)
     return false;
 
   values.erase(it);
-  keys_order.erase(std::find(keys_order.begin(), keys_order.end(), key));
+  keys_order.erase(std::ranges::find(keys_order, key));
   return true;
 }
 

Source/Core/Core/Config/DefaultLocale.cpp

@@ -59,7 +59,7 @@ static std::optional<DiscIO::Language> TryParseLanguage(const std::string& local
       "ja", "en", "de", "fr", "es", "it", "nl", "zh", "zh", "ko",
   };
 
-  const auto it = std::find(LANGUAGES.cbegin(), LANGUAGES.cend(), split_locale[0]);
+  const auto it = std::ranges::find(LANGUAGES, split_locale[0]);
   if (it == LANGUAGES.cend())
     return std::nullopt;
 
@@ -142,7 +142,7 @@ static std::optional<u8> ComputeDefaultCountry()
   if (country == "BQ" || country == "CW" || country == "SX")
     country = "AN";
 
-  const auto it = std::find(COUNTRIES.cbegin(), COUNTRIES.cend(), country);
+  const auto it = std::ranges::find(COUNTRIES, country);
   if (it == COUNTRIES.cend())
     return std::nullopt;
 

Source/Core/Core/ConfigLoaders/GameConfigLoader.cpp

@@ -153,10 +153,9 @@ static std::pair<std::string, std::string> GetINILocationFromConfig(const Locati
     return it->first;
 
   static const INIToSectionMap& ini_to_section = GetINIToSectionMap();
-  const auto it2 =
-      std::find_if(ini_to_section.begin(), ini_to_section.end(), [&location](const auto& entry) {
-        return entry.second.first == location.system && entry.second.second == location.section;
-      });
+  const auto it2 = std::ranges::find_if(ini_to_section, [&location](const auto& entry) {
+    return entry.second.first == location.system && entry.second.second == location.section;
+  });
   if (it2 != ini_to_section.end())
     return {it2->first, location.key};
 

Source/Core/Core/DSP/DSPTables.h

@@ -113,8 +113,7 @@ const DSPOPCTemplate* GetExtOpTemplate(UDSPInstruction inst);
 template <typename T, size_t N>
 auto FindByOpcode(UDSPInstruction opcode, const std::array<T, N>& data)
 {
-  return std::find_if(data.cbegin(), data.cend(), [opcode](const auto& info) {
-    return (opcode & info.opcode_mask) == info.opcode;
-  });
+  return std::ranges::find_if(
+      data, [opcode](const auto& info) { return (opcode & info.opcode_mask) == info.opcode; });
 }
 }  // namespace DSP

Source/Core/Core/Debugger/CodeTrace.cpp

@@ -252,7 +252,7 @@ HitType CodeTrace::TraceLogic(const TraceOutput& current_instr, bool first_hit)
     return HitType::SKIP;
 
   // The reg_itr will be used later for erasing.
-  auto reg_itr = std::find(m_reg_autotrack.begin(), m_reg_autotrack.end(), instr.reg0);
+  auto reg_itr = std::ranges::find(m_reg_autotrack, instr.reg0);
   const bool match_reg123 =
       (!instr.reg1.empty() && std::find(m_reg_autotrack.begin(), m_reg_autotrack.end(),
                                         instr.reg1) != m_reg_autotrack.end()) ||

Source/Core/Core/HW/AddressSpace.cpp

@@ -331,18 +331,16 @@ private:
   std::vector<AccessorMapping>::iterator FindAppropriateAccessor(const Core::CPUThreadGuard& guard,
                                                                  u32 address)
   {
-    return std::find_if(m_accessor_mappings.begin(), m_accessor_mappings.end(),
-                        [&guard, address](const AccessorMapping& a) {
-                          return a.accessors->IsValidAddress(guard, address - a.base);
-                        });
+    return std::ranges::find_if(m_accessor_mappings, [&guard, address](const AccessorMapping& a) {
+      return a.accessors->IsValidAddress(guard, address - a.base);
+    });
   }
   std::vector<AccessorMapping>::const_iterator
   FindAppropriateAccessor(const Core::CPUThreadGuard& guard, u32 address) const
   {
-    return std::find_if(m_accessor_mappings.begin(), m_accessor_mappings.end(),
-                        [&guard, address](const AccessorMapping& a) {
-                          return a.accessors->IsValidAddress(guard, address - a.base);
-                        });
+    return std::ranges::find_if(m_accessor_mappings, [&guard, address](const AccessorMapping& a) {
+      return a.accessors->IsValidAddress(guard, address - a.base);
+    });
   }
 };
 

Source/Core/Core/HW/GCMemcard/GCMemcardDirectory.cpp

@@ -146,8 +146,8 @@ std::vector<std::string> GCMemcardDirectory::GetFileNamesForGameID(const std::st
     if (!gci_file.ReadBytes(&gci.m_gci_header, Memcard::DENTRY_SIZE))
       continue;
 
-    const auto same_identity_save_it = std::find_if(
-        loaded_saves.begin(), loaded_saves.end(), [&gci](const Memcard::DEntry& entry) {
+    const auto same_identity_save_it =
+        std::ranges::find_if(loaded_saves, [&gci](const Memcard::DEntry& entry) {
           return Memcard::HasSameIdentity(gci.m_gci_header, entry);
         });
     if (same_identity_save_it != loaded_saves.end())

Source/Core/Core/HotkeyManager.cpp

@@ -420,8 +420,8 @@ ControllerEmu::ControlGroup* HotkeyManager::GetHotkeyGroup(HotkeyGroup group) co
 
 int HotkeyManager::FindGroupByID(int id) const
 {
-  const auto i = std::find_if(s_groups_info.begin(), s_groups_info.end(),
-                              [id](const auto& entry) { return entry.last >= id; });
+  const auto i =
+      std::ranges::find_if(s_groups_info, [id](const auto& entry) { return entry.last >= id; });
 
   return static_cast<int>(std::distance(s_groups_info.begin(), i));
 }

Source/Core/Core/IOS/ES/ES.cpp

@@ -527,14 +527,13 @@ void ESDevice::DoState(PointerWrap& p)
 
 ESDevice::ContextArray::iterator ESDevice::FindActiveContext(s32 fd)
 {
-  return std::find_if(m_contexts.begin(), m_contexts.end(),
-                      [fd](const auto& context) { return context.ipc_fd == fd && context.active; });
+  return std::ranges::find_if(
+      m_contexts, [fd](const auto& context) { return context.ipc_fd == fd && context.active; });
 }
 
 ESDevice::ContextArray::iterator ESDevice::FindInactiveContext()
 {
-  return std::find_if(m_contexts.begin(), m_contexts.end(),
-                      [](const auto& context) { return !context.active; });
+  return std::ranges::find_if(m_contexts, [](const auto& context) { return !context.active; });
 }
 
 std::optional<IPCReply> ESDevice::Open(const OpenRequest& request)

Source/Core/Core/IOS/ES/Formats.cpp

@@ -721,7 +721,7 @@ CertReader::CertReader(std::vector<u8>&& bytes) : SignedBlobReader(std::move(byt
       {SignatureType::ECC, PublicKeyType::ECC, sizeof(CertECC)},
   }};
 
-  const auto info = std::find_if(types.cbegin(), types.cend(), [this](const CertStructInfo& entry) {
+  const auto info = std::ranges::find_if(types, [this](const CertStructInfo& entry) {
     return m_bytes.size() >= std::get<2>(entry) && std::get<0>(entry) == GetSignatureType() &&
            std::get<1>(entry) == GetPublicKeyType();
   });

Source/Core/Core/IOS/ES/Identity.cpp

@@ -139,7 +139,7 @@ ReturnCode ESCore::VerifySign(const std::vector<u8>& hash, const std::vector<u8>
   if (certs.empty())
     return ES_EINVAL;
 
-  const auto ap_iterator = std::find_if(certs.begin(), certs.end(), [](const auto& entry) {
+  const auto ap_iterator = std::ranges::find_if(certs, [](const auto& entry) {
     return entry.first.length() > 2 && entry.first.compare(0, 2, "AP") == 0;
   });
   if (ap_iterator == certs.end())

Source/Core/Core/IOS/FS/HostBackend/File.cpp

@@ -207,8 +207,8 @@ Result<FileStatus> HostFileSystem::GetFileStatus(Fd fd)
 
 HostFileSystem::Handle* HostFileSystem::AssignFreeHandle()
 {
-  const auto it = std::find_if(m_handles.begin(), m_handles.end(),
-                               [](const Handle& handle) { return !handle.opened; });
+  const auto it =
+      std::ranges::find_if(m_handles, [](const Handle& handle) { return !handle.opened; });
   if (it == m_handles.end())
     return nullptr;
 

Source/Core/Core/IOS/IOSC.cpp

@@ -669,8 +669,7 @@ IOSC::KeyEntry::KeyEntry(ObjectType type_, ObjectSubType subtype_, std::vector<u
 
 IOSC::KeyEntries::iterator IOSC::FindFreeEntry()
 {
-  return std::find_if(m_key_entries.begin(), m_key_entries.end(),
-                      [](const auto& entry) { return !entry.in_use; });
+  return std::ranges::find_if(m_key_entries, [](const auto& entry) { return !entry.in_use; });
 }
 
 IOSC::KeyEntry* IOSC::FindEntry(Handle handle)

Source/Core/Core/IOS/USB/Bluetooth/BTEmu.cpp

@@ -473,8 +473,7 @@ bool BluetoothEmuDevice::SendEventInquiryResponse()
   static_assert(
       sizeof(SHCIEventInquiryResult) - 2 + (num_responses * sizeof(hci_inquiry_response)) < 256);
 
-  const auto iter = std::find_if(m_wiimotes.begin(), m_wiimotes.end(),
-                                 std::mem_fn(&WiimoteDevice::IsInquiryScanEnabled));
+  const auto iter = std::ranges::find_if(m_wiimotes, &WiimoteDevice::IsInquiryScanEnabled);
   if (iter == m_wiimotes.end())
   {
     // No remotes are discoverable.

Source/Core/Core/IOS/USB/USBV5.cpp

@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstring>
+#include <ranges>
 
 #include "Common/Assert.h"
 #include "Common/ChunkFile.h"
@@ -215,8 +216,8 @@ void USBV5ResourceManager::OnDeviceChange(const ChangeEvent event,
       if (interface.bAlternateSetting != 0)
         continue;
 
-      auto it = std::find_if(m_usbv5_devices.rbegin(), m_usbv5_devices.rend(),
-                             [](const USBV5Device& entry) { return !entry.in_use; });
+      auto it = std::ranges::find_if(m_usbv5_devices | std::views::reverse,
+                                     [](const USBV5Device& entry) { return !entry.in_use; });
       if (it == m_usbv5_devices.rend())
         return;
 

Source/Core/Core/IOS/USB/USB_HID/HIDv5.cpp

@@ -169,11 +169,10 @@ IPCReply USB_HIDv5::GetDeviceInfo(USBV5Device& device, const IOCtlRequest& reque
   memory.CopyToEmu(request.buffer_out + 56, &config_descriptor, sizeof(config_descriptor));
 
   std::vector<USB::InterfaceDescriptor> interfaces = host_device->GetInterfaces(0);
-  auto it = std::find_if(interfaces.begin(), interfaces.end(),
-                         [&](const USB::InterfaceDescriptor& interface) {
-                           return interface.bInterfaceNumber == device.interface_number &&
-                                  interface.bAlternateSetting == alt_setting;
-                         });
+  auto it = std::ranges::find_if(interfaces, [&](const USB::InterfaceDescriptor& interface) {
+    return interface.bInterfaceNumber == device.interface_number &&
+           interface.bAlternateSetting == alt_setting;
+  });
   if (it == interfaces.end())
     return IPCReply(IPC_EINVAL);
   it->Swap();

Source/Core/Core/IOS/USB/USB_VEN/VEN.cpp

@@ -152,11 +152,10 @@ IPCReply USB_VEN::GetDeviceInfo(USBV5Device& device, const IOCtlRequest& request
   memory.CopyToEmu(request.buffer_out + 40, &config_descriptor, sizeof(config_descriptor));
 
   std::vector<USB::InterfaceDescriptor> interfaces = host_device->GetInterfaces(0);
-  auto it = std::find_if(interfaces.begin(), interfaces.end(),
-                         [&](const USB::InterfaceDescriptor& interface) {
-                           return interface.bInterfaceNumber == device.interface_number &&
-                                  interface.bAlternateSetting == alt_setting;
-                         });
+  auto it = std::ranges::find_if(interfaces, [&](const USB::InterfaceDescriptor& interface) {
+    return interface.bInterfaceNumber == device.interface_number &&
+           interface.bAlternateSetting == alt_setting;
+  });
   if (it == interfaces.end())
     return IPCReply(IPC_EINVAL);
   it->Swap();

Source/Core/Core/PatchEngine.cpp

@@ -77,7 +77,7 @@ std::optional<PatchEntry> DeserializeLine(std::string line)
     entry.conditional = true;
   }
 
-  const auto iter = std::find(s_patch_type_strings.begin(), s_patch_type_strings.end(), items[1]);
+  const auto iter = std::ranges::find(s_patch_type_strings, items[1]);
   if (iter == s_patch_type_strings.end())
     return std::nullopt;
   entry.type = static_cast<PatchType>(std::distance(s_patch_type_strings.begin(), iter));

Source/Core/Core/PowerPC/BreakPoints.cpp

@@ -352,10 +352,9 @@ void MemChecks::Clear()
 
 TMemCheck* MemChecks::GetMemCheck(u32 address, size_t size)
 {
-  const auto iter =
-      std::find_if(m_mem_checks.begin(), m_mem_checks.end(), [address, size](const auto& mc) {
-        return mc.end_address >= address && address + size - 1 >= mc.start_address;
-      });
+  const auto iter = std::ranges::find_if(m_mem_checks, [address, size](const auto& mc) {
+    return mc.end_address >= address && address + size - 1 >= mc.start_address;
+  });
 
   // None found
   if (iter == m_mem_checks.cend())

Source/Core/Core/WC24PatchEngine.cpp

@@ -117,10 +117,9 @@ void Reload()
 
 std::optional<std::string> GetNetworkPatch(std::string_view source, IsKD is_kd)
 {
-  const auto patch =
-      std::find_if(s_patches.begin(), s_patches.end(), [&source, &is_kd](const NetworkPatch& p) {
-        return p.source == source && p.is_kd == is_kd && p.enabled;
-      });
+  const auto patch = std::ranges::find_if(s_patches, [&source, &is_kd](const NetworkPatch& p) {
+    return p.source == source && p.is_kd == is_kd && p.enabled;
+  });
   if (patch == s_patches.end())
     return std::nullopt;