# OpenShaderDesigner: Include/Utility/DirectedGraph.h Source File

Loading...
Searching...
No Matches
DirectedGraph.h
// =====================================================================================================================
// Copyright 2024 Medusa Slockbower
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// =====================================================================================================================
#ifndef DIRECTEDGRAPH_H
#define DIRECTEDGRAPH_H
#include <deque>
#include <vector>
template<typename T>
class DirectedGraph
{
public:
// Typedefs ========================================================================================================
using DataType = T;
using Node = uint32_t;
using NodeQueue = std::deque<Node>;
private:
// Data Structures =================================================================================================
struct Director
{
enum Flags
{
VALID = 0b00000000000000000000000000000001
};
Node Parent, Child, Sibling;
uint32_t Flags;
Director() : Parent(0), Child(0), Sibling(0), Flags(VALID) { }
};
using Hierarchy = std::vector<Director>;
using Storage = std::vector<DataType>;
public:
// Functions =======================================================================================================
DirectedGraph() : Graph{ Director() }, Data{ DataType() }, Freed{ } { }
[[nodiscard]] Node Parent(Node node) const { return Graph[node].Parent; }
[[nodiscard]] Node FirstChild(Node node) const { return Graph[node].Child; }
[[nodiscard]] Node NextSibling(Node node) const { return Graph[node].Sibling; }
[[nodiscard]] Node LeftMost(Node node) const
{
Node current = node;
while(node = FirstChild(current)) current = node;
return current;
}
[[nodiscard]] uint32_t Depth(Node node) const
{
uint32_t depth = 0;
while (node)
{
node = Parent(node);
++depth;
}
return depth;
}
Node Insert(const DataType& data, Node parent)
{
if(Freed.empty())
{
Freed.push_back(static_cast<Node>(Graph.size()));
Graph.push_back(Director()); Data.push_back(DataType());
}
Node next = Freed.front(); Freed.pop_front();
Director& pnode = Graph[parent];
Director& node = Graph[next];
// Setup Node
node.Parent = parent;
node.Sibling = pnode.Child;
node.Child = 0;
node.Flags = Director::VALID;
// Set parent's child
pnode.Child = next;
Data[next] = data;
return next;
}
void Erase(Node node)
{
if(node == 0) return;
Director& erased = Graph[node];
erased.Flags &= ~Director::VALID;
Freed.push_back(node);
Graph[erased.Parent].Child = erased.Sibling;
NodeQueue stack{ erased.Child };
while(stack.empty() == false)
{
Node next = stack.front(); stack.pop_front();
Director& child = Graph[next];
child.Flags &= ~Director::VALID;
Freed.push_back(next);
if(child.Sibling) stack.push_front(child.Sibling);
if(child.Child) stack.push_front(child.Child);
}
}
DataType& operator[](Node node) { return Data[node]; }
[[nodiscard]] const DataType& operator[](Node node) const { return Data[node]; }
template<typename V, typename O>
void Traverse(V& visitor)
{
Traverser<V, O> traverser(*this, visitor);
traverser();
}
private:
// Variables =======================================================================================================
Hierarchy Graph;
Storage Data;
NodeQueue Freed;
public:
// Navigation ======================================================================================================
friend class BreadthFirst;
class BreadthFirst
{
public:
BreadthFirst(DirectedGraph& graph) : Graph(graph), VisitQueue(0) { }
Node operator()(Node node)
{
node = VisitQueue.back(); VisitQueue.pop_back();
Director& current = Graph.Graph[node];
if(current.Sibling) VisitQueue.push_back(current.Sibling);
if(current.Child) VisitQueue.push_front(current.Child);
if(VisitQueue.empty()) return 0;
return node;
}
private:
DirectedGraph& Graph;
NodeQueue VisitQueue;
};
friend class PreOrder;
class PreOrder
{
public:
PreOrder(DirectedGraph& graph) : Graph(graph) { }
Node operator()(Node node)
{
Director& current = Graph.Graph[node];
if(current.Sibling) VisitQueue.push_front(current.Sibling);
if(current.Child) VisitQueue.push_front(current.Child);
if(VisitQueue.empty()) return 0;
Node next = VisitQueue.front(); VisitQueue.pop_front();
return next;
}
private:
DirectedGraph& Graph;
NodeQueue VisitQueue;
};
friend class InOrder;
class InOrder
{
public:
InOrder(DirectedGraph& graph) : Graph(graph) { }
Node operator()(Node node)
{
if(node == 0) VisitQueue.push_back(Graph.LeftMost(node));
node = VisitQueue.front(); VisitQueue.pop_front();
Director& current = Graph.Graph[node];
if(current.Sibling)
{
if(Graph.NextSibling(current.Sibling)) VisitQueue.push_back(current.Parent);
VisitQueue.push_back(Graph.LeftMost(current.Sibling));
}
return node;
}
private:
DirectedGraph& Graph;
NodeQueue VisitQueue;
};
friend class PostOrder;
class PostOrder
{
public:
PostOrder(DirectedGraph& graph) : Graph(graph) { }
Node operator()(Node node)
{
if(VisitQueue.empty()) VisitQueue.push_back(Graph.LeftMost(node));
node = VisitQueue.front(); VisitQueue.pop_front();
if(node == 0) return node;
Director& current = Graph.Graph[node];
VisitQueue.push_back(current.Sibling ? Graph.LeftMost(current.Sibling) : Graph.Parent(node));
return node;
}
private:
DirectedGraph& Graph;
NodeQueue VisitQueue;
};
template<typename V, typename O>
class Traverser
{
public:
using VisitorType = V;
using OrderType = O;
Traverser(DirectedGraph& graph, VisitorType& visitor) : Graph(graph), Visitor(visitor), Order(graph) { }
void operator()()
{
Node node = 0;
while(node = Order(node))
{
if(Visitor(Graph[node], node)) break;
}
}
private:
DirectedGraph& Graph;
VisitorType& Visitor;
OrderType Order;
};
};
#endif //DIRECTEDGRAPH_H
DirectedGraph::BreadthFirst
Definition DirectedGraph.h:150
DirectedGraph::InOrder
Definition DirectedGraph.h:196
DirectedGraph::PostOrder
Definition DirectedGraph.h:223
DirectedGraph::PreOrder
Definition DirectedGraph.h:173
DirectedGraph::Traverser
Definition DirectedGraph.h:247
DirectedGraph
Definition DirectedGraph.h:24