dolphin/Source/Core/Common/Config/Layer.cpp

149 lines
3.3 KiB
C++

// Copyright 2016 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include <algorithm>
#include <cstring>
#include <map>
#include "Common/Config/Config.h"
#include "Common/Config/Layer.h"
#include "Common/Config/Section.h"
namespace Config
{
ConfigLayerLoader::ConfigLayerLoader(LayerType layer) : m_layer(layer)
{
}
ConfigLayerLoader::~ConfigLayerLoader() = default;
LayerType ConfigLayerLoader::GetLayer() const
{
return m_layer;
}
Layer::Layer(LayerType type) : m_layer(type)
{
}
Layer::Layer(std::unique_ptr<ConfigLayerLoader> loader)
: m_layer(loader->GetLayer()), m_loader(std::move(loader))
{
Load();
}
Layer::~Layer()
{
Save();
}
bool Layer::Exists(System system, const std::string& section_name, const std::string& key)
{
Section* section = GetSection(system, section_name);
if (!section)
return false;
return section->Exists(key);
}
bool Layer::DeleteKey(System system, const std::string& section_name, const std::string& key)
{
Section* section = GetSection(system, section_name);
if (!section)
return false;
return section->Delete(key);
}
Section* Layer::GetSection(System system, const std::string& section_name)
{
for (auto& section : m_sections[system])
if (!strcasecmp(section.m_name.c_str(), section_name.c_str()))
return &section;
return nullptr;
}
Section* Layer::GetOrCreateSection(System system, const std::string& section_name)
{
Section* section = GetSection(system, section_name);
if (!section)
{
if (m_layer == LayerType::Meta)
m_sections[system].emplace_back(RecursiveSection(m_layer, system, section_name));
else
m_sections[system].emplace_back(Section(m_layer, system, section_name));
section = &m_sections[system].back();
}
return section;
}
void Layer::Load()
{
if (m_loader)
m_loader->Load(this);
ClearDirty();
InvokeConfigChangedCallbacks();
}
void Layer::Save()
{
if (!m_loader || !IsDirty())
return;
m_loader->Save(this);
ClearDirty();
InvokeConfigChangedCallbacks();
}
LayerType Layer::GetLayer() const
{
return m_layer;
}
const LayerMap& Layer::GetLayerMap() const
{
return m_sections;
}
ConfigLayerLoader* Layer::GetLoader() const
{
return m_loader.get();
}
bool Layer::IsDirty() const
{
return std::any_of(m_sections.begin(), m_sections.end(), [](const auto& system) {
return std::any_of(system.second.begin(), system.second.end(),
[](const auto& section) { return section.IsDirty(); });
});
}
void Layer::ClearDirty()
{
std::for_each(m_sections.begin(), m_sections.end(), [](auto& system) {
std::for_each(system.second.begin(), system.second.end(),
[](auto& section) { section.ClearDirty(); });
});
}
RecursiveLayer::RecursiveLayer() : Layer(LayerType::Meta)
{
}
Section* RecursiveLayer::GetSection(System system, const std::string& section_name)
{
// Always queries backwards recursively, so it doesn't matter if it exists or not on this layer
return GetOrCreateSection(system, section_name);
}
Section* RecursiveLayer::GetOrCreateSection(System system, const std::string& section_name)
{
Section* section = Layer::GetSection(system, section_name);
if (!section)
{
m_sections[system].emplace_back(RecursiveSection(m_layer, system, section_name));
section = &m_sections[system].back();
}
return section;
}
}