pollymc/logic/SeparatorPrefixTree.h

299 lines
5.6 KiB
C
Raw Normal View History

#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;
};