mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 05:47:56 -07:00
397b27e665
Given this is what occurs in both constructors (as one just passes through to another), we can just initialize the member directly. While we're at it, amend the struct to follow the general ordering convention of: <new types> <functions> <variables>
101 lines
2.5 KiB
C++
101 lines
2.5 KiB
C++
// Copyright 2018 Dolphin Emulator Project
|
|
// Licensed under GPLv2+
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "Common/Debug/MemoryPatches.h"
|
|
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#include <utility>
|
|
|
|
namespace Common::Debug
|
|
{
|
|
MemoryPatch::MemoryPatch(u32 address_, std::vector<u8> value_)
|
|
: address(address_), value(std::move(value_))
|
|
{
|
|
}
|
|
|
|
MemoryPatch::MemoryPatch(u32 address, u32 value)
|
|
: MemoryPatch(address, {static_cast<u8>(value >> 24), static_cast<u8>(value >> 16),
|
|
static_cast<u8>(value >> 8), static_cast<u8>(value)})
|
|
{
|
|
}
|
|
|
|
MemoryPatches::MemoryPatches() = default;
|
|
MemoryPatches::~MemoryPatches() = default;
|
|
|
|
void MemoryPatches::SetPatch(u32 address, u32 value)
|
|
{
|
|
const std::size_t index = m_patches.size();
|
|
m_patches.emplace_back(address, value);
|
|
Patch(index);
|
|
}
|
|
|
|
void MemoryPatches::SetPatch(u32 address, std::vector<u8> value)
|
|
{
|
|
const std::size_t index = m_patches.size();
|
|
m_patches.emplace_back(address, std::move(value));
|
|
Patch(index);
|
|
}
|
|
|
|
const std::vector<MemoryPatch>& MemoryPatches::GetPatches() const
|
|
{
|
|
return m_patches;
|
|
}
|
|
|
|
void MemoryPatches::UnsetPatch(u32 address)
|
|
{
|
|
const auto it = std::remove_if(m_patches.begin(), m_patches.end(),
|
|
[address](const auto& patch) { return patch.address == address; });
|
|
|
|
if (it == m_patches.end())
|
|
return;
|
|
|
|
const std::size_t size = m_patches.size();
|
|
std::size_t index = size - std::distance(it, m_patches.end());
|
|
while (index < size)
|
|
{
|
|
DisablePatch(index);
|
|
++index;
|
|
}
|
|
m_patches.erase(it, m_patches.end());
|
|
}
|
|
|
|
void MemoryPatches::EnablePatch(std::size_t index)
|
|
{
|
|
if (m_patches[index].is_enabled == MemoryPatch::State::Enabled)
|
|
return;
|
|
m_patches[index].is_enabled = MemoryPatch::State::Enabled;
|
|
Patch(index);
|
|
}
|
|
|
|
void MemoryPatches::DisablePatch(std::size_t index)
|
|
{
|
|
if (m_patches[index].is_enabled == MemoryPatch::State::Disabled)
|
|
return;
|
|
m_patches[index].is_enabled = MemoryPatch::State::Disabled;
|
|
Patch(index);
|
|
}
|
|
|
|
bool MemoryPatches::HasEnabledPatch(u32 address) const
|
|
{
|
|
return std::any_of(m_patches.begin(), m_patches.end(), [address](const MemoryPatch& patch) {
|
|
return patch.address == address && patch.is_enabled == MemoryPatch::State::Enabled;
|
|
});
|
|
}
|
|
|
|
void MemoryPatches::RemovePatch(std::size_t index)
|
|
{
|
|
DisablePatch(index);
|
|
m_patches.erase(m_patches.begin() + index);
|
|
}
|
|
|
|
void MemoryPatches::ClearPatches()
|
|
{
|
|
const std::size_t size = m_patches.size();
|
|
for (std::size_t index = 0; index < size; ++index)
|
|
DisablePatch(index);
|
|
m_patches.clear();
|
|
}
|
|
} // namespace Common::Debug
|