Add formatter

src/operation/utility.jl

@@ -1,107 +1,111 @@
 
 function isempty(operations::PossibleOperations)
-   return isempty(operations.nodeFusions) && 
-          isempty(operations.nodeReductions) && 
-          isempty(operations.nodeSplits)
+    return isempty(operations.nodeFusions) &&
+           isempty(operations.nodeReductions) &&
+           isempty(operations.nodeSplits)
 end
 
 function length(operations::PossibleOperations)
-   return (nodeFusions = length(operations.nodeFusions),
-           nodeReductions = length(operations.nodeReductions),
-           nodeSplits = length(operations.nodeSplits))
+    return (
+        nodeFusions = length(operations.nodeFusions),
+        nodeReductions = length(operations.nodeReductions),
+        nodeSplits = length(operations.nodeSplits),
+    )
 end
 
 function delete!(operations::PossibleOperations, op::NodeFusion)
-   delete!(operations.nodeFusions, op)
-   return operations
+    delete!(operations.nodeFusions, op)
+    return operations
 end
 
 function delete!(operations::PossibleOperations, op::NodeReduction)
-   delete!(operations.nodeReductions, op)
-   return operations
+    delete!(operations.nodeReductions, op)
+    return operations
 end
 
 function delete!(operations::PossibleOperations, op::NodeSplit)
-   delete!(operations.nodeSplits, op)
-   return operations
+    delete!(operations.nodeSplits, op)
+    return operations
 end
 
 
 function can_fuse(n1::ComputeTaskNode, n2::DataTaskNode, n3::ComputeTaskNode)
-   if !is_child(n1, n2) || !is_child(n2, n3)
-      # the checks are redundant but maybe a good sanity check
-      return false
-   end
+    if !is_child(n1, n2) || !is_child(n2, n3)
+        # the checks are redundant but maybe a good sanity check
+        return false
+    end
 
-   if length(n2.parents) != 1 || length(n2.children) != 1 || length(n1.parents) != 1
-      return false
-   end
+    if length(n2.parents) != 1 ||
+       length(n2.children) != 1 ||
+       length(n1.parents) != 1
+        return false
+    end
 
-   return true
+    return true
 end
 
 function can_reduce(n1::Node, n2::Node)
-   if (n1.task != n2.task)
-      return false
-   end
-   
-   n1_length = length(n1.children)
-   n2_length = length(n2.children)
+    if (n1.task != n2.task)
+        return false
+    end
 
-   if (n1_length != n2_length)
-      return false
-   end
+    n1_length = length(n1.children)
+    n2_length = length(n2.children)
 
-   # this seems to be the most common case so do this first
-   # doing it manually is a lot faster than using the sets for a general solution
-   if (n1_length == 2)
-      if (n1.children[1] != n2.children[1])
-         if (n1.children[1] != n2.children[2])
+    if (n1_length != n2_length)
+        return false
+    end
+
+    # this seems to be the most common case so do this first
+    # doing it manually is a lot faster than using the sets for a general solution
+    if (n1_length == 2)
+        if (n1.children[1] != n2.children[1])
+            if (n1.children[1] != n2.children[2])
+                return false
+            end
+            # 1_1 == 2_2
+            if (n1.children[2] != n2.children[1])
+                return false
+            end
+            return true
+        end
+
+        # 1_1 == 2_1
+        if (n1.children[2] != n2.children[2])
             return false
-         end
-         # 1_1 == 2_2
-         if (n1.children[2] != n2.children[1])
-            return false
-         end
-         return true
-      end
+        end
+        return true
+    end
 
-      # 1_1 == 2_1
-      if (n1.children[2] != n2.children[2])
-         return false
-      end
-      return true
-   end
+    # this is simple
+    if (n1_length == 1)
+        return n1.children[1] == n2.children[1]
+    end
 
-   # this is simple
-   if (n1_length == 1)
-      return n1.children[1] == n2.children[1]
-   end
-   
-   # this takes a long time
-   return Set(n1.children) == Set(n2.children)
+    # this takes a long time
+    return Set(n1.children) == Set(n2.children)
 end
 
 function can_split(n::Node)
-   return length(parents(n)) > 1
+    return length(parents(n)) > 1
 end
 
 function ==(op1::Operation, op2::Operation)
-   return false
+    return false
 end
 
 function ==(op1::NodeFusion, op2::NodeFusion)
-   # there can only be one node fusion on a given data task, so if the data task is the same, the fusion is the same
-   return op1.input[2] == op2.input[2]
+    # there can only be one node fusion on a given data task, so if the data task is the same, the fusion is the same
+    return op1.input[2] == op2.input[2]
 end
 
 function ==(op1::NodeReduction, op2::NodeReduction)
-   # node reductions are equal exactly if their first input is the same
-   return op1.input[1].id == op2.input[1].id
+    # node reductions are equal exactly if their first input is the same
+    return op1.input[1].id == op2.input[1].id
 end
 
 function ==(op1::NodeSplit, op2::NodeSplit)
-   return op1.input == op2.input
+    return op1.input == op2.input
 end
 
 copy(id::UUID) = UUID(id.value)