Add formatter

src/node/create.jl

@@ -1,23 +1,23 @@
 function make_node(t::AbstractTask)
-   error("Cannot make a node from this task type")
+    return error("Cannot make a node from this task type")
 end
 
 function make_node(t::AbstractDataTask)
-   return DataTaskNode(t)
+    return DataTaskNode(t)
 end
 
 function make_node(t::AbstractComputeTask)
-   return ComputeTaskNode(t)
+    return ComputeTaskNode(t)
 end
 
 function make_edge(n1::Node, n2::Node)
-   error("Can only create edges from compute to data node or reverse")
+    return error("Can only create edges from compute to data node or reverse")
 end
 
 function make_edge(n1::ComputeTaskNode, n2::DataTaskNode)
-   return Edge((n1, n2))
+    return Edge((n1, n2))
 end
 
 function make_edge(n1::DataTaskNode, n2::ComputeTaskNode)
-   return Edge((n1, n2))
+    return Edge((n1, n2))
 end

src/node/print.jl

@@ -1,7 +1,7 @@
 function show(io::IO, n::Node)
-   print(io, "Node(", n.task, ")")
+    return print(io, "Node(", n.task, ")")
 end
 
 function show(io::IO, e::Edge)
-   print(io, "Edge(", e.edge[1], ", ", e.edge[2], ")")
+    return print(io, "Edge(", e.edge[1], ", ", e.edge[2], ")")
 end

src/node/properties.jl

@@ -3,50 +3,50 @@ is_exit_node(node::Node) = length(node.parents) == 0
 
 # children = prerequisite nodes, nodes that need to execute before the task, edges point into this task
 function children(node::Node)
-   return copy(node.children)
+    return copy(node.children)
 end
 
 # parents = subsequent nodes, nodes that need this node to execute, edges point from this task
 function parents(node::Node)
-   return copy(node.parents)
+    return copy(node.parents)
 end
 
 # siblings = all children of any parents, no duplicates, includes the node itself
 function siblings(node::Node)
-   result = Set{Node}()
-   push!(result, node)
-   for parent in node.parents
-      union!(result, parent.children)
-   end
+    result = Set{Node}()
+    push!(result, node)
+    for parent in node.parents
+        union!(result, parent.children)
+    end
 
-   return result
+    return result
 end
 
 # partners = all parents of any children, no duplicates, includes the node itself
 function partners(node::Node)
-   result = Set{Node}()
-   push!(result, node)
-   for child in node.children
-      union!(result, child.parents)
-   end
+    result = Set{Node}()
+    push!(result, node)
+    for child in node.children
+        union!(result, child.parents)
+    end
 
-   return result
+    return result
 end
 
 # alternative version to partners(Node), avoiding allocation of a new set
 # works on the given set and returns nothing
 function partners(node::Node, set::Set{Node})
-   push!(set, node)
-   for child in node.children
-      union!(set, child.parents)
-   end
-   return nothing
+    push!(set, node)
+    for child in node.children
+        union!(set, child.parents)
+    end
+    return nothing
 end
 
 function is_parent(potential_parent, node)
-   return potential_parent in node.parents
+    return potential_parent in node.parents
 end
 
 function is_child(potential_child, node)
-   return potential_child in node.children
+    return potential_child in node.children
 end

src/node/type.jl

@@ -12,49 +12,84 @@ abstract type Node end
 abstract type Operation end
 
 mutable struct DataTaskNode <: Node
-   task::AbstractDataTask
-   
-   # use vectors as sets have way too much memory overhead
-   parents::Vector{Node}
-   children::Vector{Node}
+    task::AbstractDataTask
 
-   # need a unique identifier unique to every *constructed* node
-   # however, it can be copied when splitting a node
-   id::Base.UUID
+    # use vectors as sets have way too much memory overhead
+    parents::Vector{Node}
+    children::Vector{Node}
 
-   # the NodeReduction involving this node, if it exists
-   # Can't use the NodeReduction type here because it's not yet defined
-   nodeReduction::Union{Operation, Missing}
+    # need a unique identifier unique to every *constructed* node
+    # however, it can be copied when splitting a node
+    id::Base.UUID
 
-   # the NodeSplit involving this node, if it exists
-   nodeSplit::Union{Operation, Missing}
+    # the NodeReduction involving this node, if it exists
+    # Can't use the NodeReduction type here because it's not yet defined
+    nodeReduction::Union{Operation, Missing}
 
-   # the node fusion involving this node, if it exists
-   nodeFusion::Union{Operation, Missing}
+    # the NodeSplit involving this node, if it exists
+    nodeSplit::Union{Operation, Missing}
+
+    # the node fusion involving this node, if it exists
+    nodeFusion::Union{Operation, Missing}
 end
 
 # same as DataTaskNode
 mutable struct ComputeTaskNode <: Node
-   task::AbstractComputeTask
-   parents::Vector{Node}
-   children::Vector{Node}
-   id::Base.UUID
+    task::AbstractComputeTask
+    parents::Vector{Node}
+    children::Vector{Node}
+    id::Base.UUID
 
-   nodeReduction::Union{Operation, Missing}
-   nodeSplit::Union{Operation, Missing}
+    nodeReduction::Union{Operation, Missing}
+    nodeSplit::Union{Operation, Missing}
 
-   # for ComputeTasks there can be multiple fusions, unlike the DataTasks
-   nodeFusions::Vector{Operation}
+    # for ComputeTasks there can be multiple fusions, unlike the DataTasks
+    nodeFusions::Vector{Operation}
 end
 
-DataTaskNode(t::AbstractDataTask) = DataTaskNode(t, Vector{Node}(), Vector{Node}(), UUIDs.uuid1(rng[threadid()]), missing, missing, missing)
-ComputeTaskNode(t::AbstractComputeTask) = ComputeTaskNode(t, Vector{Node}(), Vector{Node}(), UUIDs.uuid1(rng[threadid()]), missing, missing, Vector{NodeFusion}())
+DataTaskNode(t::AbstractDataTask) = DataTaskNode(
+    t,
+    Vector{Node}(),
+    Vector{Node}(),
+    UUIDs.uuid1(rng[threadid()]),
+    missing,
+    missing,
+    missing,
+)
+ComputeTaskNode(t::AbstractComputeTask) = ComputeTaskNode(
+    t,
+    Vector{Node}(),
+    Vector{Node}(),
+    UUIDs.uuid1(rng[threadid()]),
+    missing,
+    missing,
+    Vector{NodeFusion}(),
+)
 
 struct Edge
-   # edge points from child to parent
-   edge::Union{Tuple{DataTaskNode, ComputeTaskNode}, Tuple{ComputeTaskNode, DataTaskNode}}
+    # edge points from child to parent
+    edge::Union{
+        Tuple{DataTaskNode, ComputeTaskNode},
+        Tuple{ComputeTaskNode, DataTaskNode},
+    }
 end
 
 copy(m::Missing) = missing
-copy(n::ComputeTaskNode) =  ComputeTaskNode(copy(n.task), copy(n.parents), copy(n.children), UUIDs.uuid1(rng[threadid()]), copy(n.nodeReduction), copy(n.nodeSplit), copy(n.nodeFusions))
-copy(n::DataTaskNode) = DataTaskNode(copy(n.task), copy(n.parents), copy(n.children), UUIDs.uuid1(rng[threadid()]), copy(n.nodeReduction), copy(n.nodeSplit), copy(n.nodeFusion))
+copy(n::ComputeTaskNode) = ComputeTaskNode(
+    copy(n.task),
+    copy(n.parents),
+    copy(n.children),
+    UUIDs.uuid1(rng[threadid()]),
+    copy(n.nodeReduction),
+    copy(n.nodeSplit),
+    copy(n.nodeFusions),
+)
+copy(n::DataTaskNode) = DataTaskNode(
+    copy(n.task),
+    copy(n.parents),
+    copy(n.children),
+    UUIDs.uuid1(rng[threadid()]),
+    copy(n.nodeReduction),
+    copy(n.nodeSplit),
+    copy(n.nodeFusion),
+)

src/node/validate.jl

@@ -1,43 +1,43 @@
 function is_valid_node(graph::DAG, node::Node)
-   @assert node in graph "Node is not part of the given graph!"
-   
-   for parent in node.parents
-       @assert typeof(parent) != typeof(node) "Node's type is the same as its parent's!"
-       @assert parent in graph "Node's parent is not in the same graph!"
-       @assert node in parent.children "Node is not a child of its parent!"
-   end
+    @assert node in graph "Node is not part of the given graph!"
 
-   for child in node.children
-       @assert typeof(child) != typeof(node) "Node's type is the same as its child's!"
-       @assert child in graph "Node's child is not in the same graph!"
-       @assert node in child.parents "Node is not a parent of its child!"
-   end
+    for parent in node.parents
+        @assert typeof(parent) != typeof(node) "Node's type is the same as its parent's!"
+        @assert parent in graph "Node's parent is not in the same graph!"
+        @assert node in parent.children "Node is not a child of its parent!"
+    end
 
-   if !ismissing(node.nodeReduction)
-       @assert is_valid(graph, node.nodeReduction)
-   end
-   if !ismissing(node.nodeSplit)
-       @assert is_valid(graph, node.nodeSplit)
-   end
-   return true
+    for child in node.children
+        @assert typeof(child) != typeof(node) "Node's type is the same as its child's!"
+        @assert child in graph "Node's child is not in the same graph!"
+        @assert node in child.parents "Node is not a parent of its child!"
+    end
+
+    if !ismissing(node.nodeReduction)
+        @assert is_valid(graph, node.nodeReduction)
+    end
+    if !ismissing(node.nodeSplit)
+        @assert is_valid(graph, node.nodeSplit)
+    end
+    return true
 end
 
 # call with @assert
 function is_valid(graph::DAG, node::ComputeTaskNode)
-   @assert is_valid_node(graph, node)
+    @assert is_valid_node(graph, node)
 
-   for nf in node.nodeFusions
-       @assert is_valid(graph, nf)
-   end
-   return true
+    for nf in node.nodeFusions
+        @assert is_valid(graph, nf)
+    end
+    return true
 end
 
 # call with @assert
 function is_valid(graph::DAG, node::DataTaskNode)
-   @assert is_valid_node(graph, node)
+    @assert is_valid_node(graph, node)
 
-   if !ismissing(node.nodeFusion)
-       @assert is_valid(graph, node.nodeFusion)
-   end
-   return true
+    if !ismissing(node.nodeFusion)
+        @assert is_valid(graph, node.nodeFusion)
+    end
+    return true
 end