mirror of
https://github.com/MultiMC/MultiMC5.git
synced 2024-09-03 21:49:13 +00:00
299 lines
7.5 KiB
C++
299 lines
7.5 KiB
C++
#pragma once
|
|
#include <QString>
|
|
#include <QMap>
|
|
#include <QStringList>
|
|
|
|
template <char Tseparator>
|
|
class SeparatorPrefixTree
|
|
{
|
|
public:
|
|
SeparatorPrefixTree(QStringList paths)
|
|
{
|
|
insert(paths);
|
|
}
|
|
|
|
SeparatorPrefixTree(bool contained = false)
|
|
{
|
|
m_contained = contained;
|
|
}
|
|
|
|
void insert(QStringList paths)
|
|
{
|
|
for(auto &path: paths)
|
|
{
|
|
insert(path);
|
|
}
|
|
}
|
|
|
|
/// insert an exact path into the tree
|
|
SeparatorPrefixTree & insert(QString path)
|
|
{
|
|
auto sepIndex = path.indexOf(Tseparator);
|
|
if(sepIndex == -1)
|
|
{
|
|
children[path] = SeparatorPrefixTree(true);
|
|
return children[path];
|
|
}
|
|
else
|
|
{
|
|
auto prefix = path.left(sepIndex);
|
|
if(!children.contains(prefix))
|
|
{
|
|
children[prefix] = SeparatorPrefixTree(false);
|
|
}
|
|
return children[prefix].insert(path.mid(sepIndex + 1));
|
|
}
|
|
}
|
|
|
|
/// is the path fully contained in the tree?
|
|
bool contains(QString path) const
|
|
{
|
|
auto node = find(path);
|
|
return node != nullptr;
|
|
}
|
|
|
|
/// does the tree cover a path? That means the prefix of the path is contained in the tree
|
|
bool covers(QString path) const
|
|
{
|
|
// if we found some valid node, it's good enough. the tree covers the path
|
|
if(m_contained)
|
|
{
|
|
return true;
|
|
}
|
|
auto sepIndex = path.indexOf(Tseparator);
|
|
if(sepIndex == -1)
|
|
{
|
|
auto found = children.find(path);
|
|
if(found == children.end())
|
|
{
|
|
return false;
|
|
}
|
|
return (*found).covers(QString());
|
|
}
|
|
else
|
|
{
|
|
auto prefix = path.left(sepIndex);
|
|
auto found = children.find(prefix);
|
|
if(found == children.end())
|
|
{
|
|
return false;
|
|
}
|
|
return (*found).covers(path.mid(sepIndex + 1));
|
|
}
|
|
}
|
|
|
|
/// return the contained path that covers the path specified
|
|
QString cover(QString path) const
|
|
{
|
|
// if we found some valid node, it's good enough. the tree covers the path
|
|
if(m_contained)
|
|
{
|
|
return QString("");
|
|
}
|
|
auto sepIndex = path.indexOf(Tseparator);
|
|
if(sepIndex == -1)
|
|
{
|
|
auto found = children.find(path);
|
|
if(found == children.end())
|
|
{
|
|
return QString();
|
|
}
|
|
auto nested = (*found).cover(QString());
|
|
if(nested.isNull())
|
|
{
|
|
return nested;
|
|
}
|
|
if(nested.isEmpty())
|
|
return path;
|
|
return path + Tseparator + nested;
|
|
}
|
|
else
|
|
{
|
|
auto prefix = path.left(sepIndex);
|
|
auto found = children.find(prefix);
|
|
if(found == children.end())
|
|
{
|
|
return QString();
|
|
}
|
|
auto nested = (*found).cover(path.mid(sepIndex + 1));
|
|
if(nested.isNull())
|
|
{
|
|
return nested;
|
|
}
|
|
if(nested.isEmpty())
|
|
return prefix;
|
|
return prefix + Tseparator + nested;
|
|
}
|
|
}
|
|
|
|
/// Does the path-specified node exist in the tree? It does not have to be contained.
|
|
bool exists(QString path) const
|
|
{
|
|
auto sepIndex = path.indexOf(Tseparator);
|
|
if(sepIndex == -1)
|
|
{
|
|
auto found = children.find(path);
|
|
if(found == children.end())
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
auto prefix = path.left(sepIndex);
|
|
auto found = children.find(prefix);
|
|
if(found == children.end())
|
|
{
|
|
return false;
|
|
}
|
|
return (*found).exists(path.mid(sepIndex + 1));
|
|
}
|
|
}
|
|
|
|
/// find a node in the tree by name
|
|
const SeparatorPrefixTree * find(QString path) const
|
|
{
|
|
auto sepIndex = path.indexOf(Tseparator);
|
|
if(sepIndex == -1)
|
|
{
|
|
auto found = children.find(path);
|
|
if(found == children.end())
|
|
{
|
|
return nullptr;
|
|
}
|
|
return &(*found);
|
|
}
|
|
else
|
|
{
|
|
auto prefix = path.left(sepIndex);
|
|
auto found = children.find(prefix);
|
|
if(found == children.end())
|
|
{
|
|
return nullptr;
|
|
}
|
|
return (*found).find(path.mid(sepIndex + 1));
|
|
}
|
|
}
|
|
|
|
/// is this a leaf node?
|
|
bool leaf() const
|
|
{
|
|
return children.isEmpty();
|
|
}
|
|
|
|
/// is this node actually contained in the tree, or is it purely structural?
|
|
bool contained() const
|
|
{
|
|
return m_contained;
|
|
}
|
|
|
|
/// Remove a path from the tree
|
|
bool remove(QString path)
|
|
{
|
|
return removeInternal(path) != Failed;
|
|
}
|
|
|
|
/// Clear all children of this node tree node
|
|
void clear()
|
|
{
|
|
children.clear();
|
|
}
|
|
|
|
QStringList toStringList() const
|
|
{
|
|
QStringList collected;
|
|
// collecting these is more expensive.
|
|
auto iter = children.begin();
|
|
while(iter != children.end())
|
|
{
|
|
QStringList list = iter.value().toStringList();
|
|
for(int i = 0; i < list.size(); i++)
|
|
{
|
|
list[i] = iter.key() + Tseparator + list[i];
|
|
}
|
|
collected.append(list);
|
|
if((*iter).m_contained)
|
|
{
|
|
collected.append(iter.key());
|
|
}
|
|
iter++;
|
|
}
|
|
return collected;
|
|
}
|
|
private:
|
|
enum Removal
|
|
{
|
|
Failed,
|
|
Succeeded,
|
|
HasChildren
|
|
};
|
|
Removal removeInternal(QString path = QString())
|
|
{
|
|
if(path.isEmpty())
|
|
{
|
|
if(!m_contained)
|
|
{
|
|
// remove all children - we are removing a prefix
|
|
clear();
|
|
return Succeeded;
|
|
}
|
|
m_contained = false;
|
|
if(children.size())
|
|
{
|
|
return HasChildren;
|
|
}
|
|
return Succeeded;
|
|
}
|
|
Removal remStatus = Failed;
|
|
QString childToRemove;
|
|
auto sepIndex = path.indexOf(Tseparator);
|
|
if(sepIndex == -1)
|
|
{
|
|
childToRemove = path;
|
|
auto found = children.find(childToRemove);
|
|
if(found == children.end())
|
|
{
|
|
return Failed;
|
|
}
|
|
remStatus = (*found).removeInternal();
|
|
}
|
|
else
|
|
{
|
|
childToRemove = path.left(sepIndex);
|
|
auto found = children.find(childToRemove);
|
|
if(found == children.end())
|
|
{
|
|
return Failed;
|
|
}
|
|
remStatus = (*found).removeInternal(path.mid(sepIndex + 1));
|
|
}
|
|
switch (remStatus)
|
|
{
|
|
case Failed:
|
|
case HasChildren:
|
|
{
|
|
return remStatus;
|
|
}
|
|
case Succeeded:
|
|
{
|
|
children.remove(childToRemove);
|
|
if(m_contained)
|
|
{
|
|
return HasChildren;
|
|
}
|
|
if(children.size())
|
|
{
|
|
return HasChildren;
|
|
}
|
|
return Succeeded;
|
|
}
|
|
}
|
|
return Failed;
|
|
}
|
|
|
|
private:
|
|
QMap<QString,SeparatorPrefixTree<Tseparator>> children;
|
|
bool m_contained = false;
|
|
};
|