From: Thomas Walker Lynch Date: Fri, 8 Nov 2024 15:55:55 +0000 (+0000) Subject: updates to the _ identifier convention for class. Tests up... X-Git-Url: https://git.reasoningtechnology.com/style/static/%7Bstyle.link%7D?a=commitdiff_plain;h=e91208825162897f17c2dd0ace6a4768f258e7de;p=Ariadne updates to the _ identifier convention for class. Tests up through Graph (all writtent thus far) now passing. --- diff --git a/developer/document/GraphDirectedAcyclic_1.txt b/developer/document/GraphDirectedAcyclic_1.txt new file mode 100644 index 0000000..7a202e2 --- /dev/null +++ b/developer/document/GraphDirectedAcyclic_1.txt @@ -0,0 +1,84 @@ + /*-------------------------------------------------------------------------------- + Interface + + 1. nodes are referenced by label. + + 2. A list is a kind of sequence. It consists of a leftmost item, subsequent + items, and a rightmost item. + + 3. A node list consists of a leftmost node, subsequent nodes, and a rightmost node. + + 4. `path_stack` + + The `path_stack` is a list. Each item in the stack is a node list. + + The rightmost items is the top of the stack. + + The leftmost item is a list of root nodes, where traversal of the graph + starts. + + Given two adjacent items on the path stack, say e0 and e1: + + Say k0 is the leftmost node on the node list e0. + + The e1 will be the neighbor (child) list from node k0. + + Hence, the path stack consists of the child lists of nodes along + a traversal. We chose a leftmost traversal. + + e0: k_0 k_1 ... k_2 + + e1: k_0_0 k_0_1 ... k_0_2 ; children of k_0 + + e2: K_0_0_0 k_0_0_1 ... k_0_0_2 ; children of k_0_0 + + + 5. `path` + + A list of the leftmost nodes from a path stack. + + Given that e0 is a root node, `path` will consist of + + k_0, k_0_0, k_0_0_0 ... k_0_0..._0 + + Within the context of a path, k_0 is the leftmost item, and k_n is the + rightmost item. + + + 6. removing a cycle + + This is a build tool. Each node corresponds to a build objective, and the + neighbor nodes are dependencies. A neighbor node is a child node in our + tree descent, and is a dependency to our build tool. + + This routine is called as part of the analysis phase. Nothing is + built here, rather we are merely marking dependency cycles that we + find when descending from the root nodes. + + When we find a cycle, we remove those nodes from the current traversal + path, because we do not went the analysis to do in circles. It is + possible that there are spurs that emanate from the cycle, and following + these might lead to finding more cycles. + + Our build tool (which is not in this file) will stop descending through + the graph upon finding a cycle, and the effects of this will cause + upstream nodes to also not be built. Hence, the cycles hidden behind + other cycles are irrelevant. + + However, if we want to make routine of more general use, then the + discovered cycles should be pushed on to a cycle stack, and then each + item on the cycle stack would be used as root nodes for a new cycle + search. Note the leftmost cycle on each recursive search on the leftmost + node, will be the original cycle. + */ + + /* + Given a path to a node in the graph, `left_path`. + + Checks if the rightmost node (referenced by label) recurs earlier in the path. + Presumably the rightmost node has been recently appended to the path. + + If there is no cycle, returns null, otherwise returns the interval [i ,n], + of indexes into the path where the cycle is found. `n` will always be + the index of the rightmost node in the path list. + */ diff --git a/developer/javac/Ariadne_File.java b/developer/javac/Ariadne_File.java new file mode 100644 index 0000000..825b499 --- /dev/null +++ b/developer/javac/Ariadne_File.java @@ -0,0 +1,76 @@ +package com.ReasoningTechnology.Ariadne; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class Ariadne_File { + static boolean debug = false; + + public static Map unpack_file_path(String file_fp) { + if (debug) System.out.println("unpack_file_path::file_fp: " + file_fp); + + // Use java.io.File explicitly to avoid conflict with the custom Ariadne_File class + java.io.File file = new java.io.File(file_fp); + String parent_dp = (file.getParent() != null) ? file.getParent() : ""; + + if (!parent_dp.isEmpty() && !parent_dp.endsWith(java.io.File.separator)) { + parent_dp += java.io.File.separator; + } + + String file_fn = file.getName(); + String file_fn_base = file_fn; + String file_fn_ext = ""; + + int last_index = file_fn.lastIndexOf('.'); + if (last_index > 0) { + file_fn_base = file_fn.substring(0, last_index); + if (last_index + 1 < file_fn.length()) { + file_fn_ext = file_fn.substring(last_index + 1); + } + } + + Map ret_val = new HashMap<>(); + ret_val.put("dp", parent_dp); + ret_val.put("fn", file_fn); + ret_val.put("fn_base", file_fn_base); + ret_val.put("fn_ext", file_fn_ext); + + if (debug) System.out.println("unpack_file_path::ret_val: " + ret_val); + + return ret_val; + } + + public static boolean file_exists_q(String fp_string) { + Path fp_object = Paths.get(fp_string); + return Files.exists(fp_object); + } + + /* + Given a target_fp and a list of dependency_fp. + + Returns false if the target is newer than all dependencies or if a file is missing; + otherwise, returns true. + */ + public static boolean newer_than_all(String target_fp_string, List dependency_fp_list) throws IOException { + Path target_fp_object = Paths.get(target_fp_string); + if (!Files.exists(target_fp_object)) return false; + + long target_last_modified_time = Files.getLastModifiedTime(target_fp_object).toMillis(); + + return dependency_fp_list.stream().allMatch(dependency_fp -> { + try { + Path dependency_fp_object = Paths.get(dependency_fp); + if (!Files.exists(dependency_fp_object)) return false; + long dependency_last_modified_time = Files.getLastModifiedTime(dependency_fp_object).toMillis(); + return target_last_modified_time > dependency_last_modified_time; + } catch (IOException e) { + return false; + } + }); + } +} diff --git a/developer/javac/Ariadne_Graph.java b/developer/javac/Ariadne_Graph.java new file mode 100644 index 0000000..2dd28b6 --- /dev/null +++ b/developer/javac/Ariadne_Graph.java @@ -0,0 +1,62 @@ +package com.ReasoningTechnology.Ariadne; + +import java.util.HashMap; +import java.util.Map; + +public class Ariadne_Graph { + + /*-------------------------------------------------------------------------------- + constructors + */ + + public Ariadne_Graph(Map node_map, Ariadne_ProductionList recognizer_f_list) { + if (node_map == null && recognizer_f_list == null) { + System.err.println("Ariadne_Graph: At least one of 'node_map' (Map) or 'recognizer_f_list' (List) must be provided."); + System.exit(1); + } + + // Initialize each of node_map and recognizer_f_list to empty collections if null + this.node_map = (node_map != null) ? node_map : new HashMap<>(); + this.recognizer_f_list = (recognizer_f_list != null) ? recognizer_f_list : new Ariadne_ProductionList(); + } + + /*-------------------------------------------------------------------------------- + instance data + */ + + private static boolean debug = true; + private Map node_map; + private Ariadne_ProductionList recognizer_f_list; + + /*-------------------------------------------------------------------------------- + interface + */ + + // Lookup method to find a node by its label + public Ariadne_Node lookup(Ariadne_Label node_label, boolean verbose) { + if (node_label == null || node_label.isEmpty()) { + if (verbose) { + System.out.println("lookup:: given node_label is null or empty."); + } + return null; + } + + // Try to retrieve the node from the map + Ariadne_Node node = this.node_map.get(node_label); + + if (verbose) { + if (node != null) { + System.out.println("lookup:: found node: " + node); + } else { + System.out.println("lookup:: node not found for label: " + node_label); + } + } + + return node; + } + + // Overloaded lookup method with default verbosity (true) + public Ariadne_Node lookup(Ariadne_Label node_label) { + return lookup(node_label, true); + } +} diff --git a/developer/javac/Ariadne_GraphDirectedAcyclic.java b/developer/javac/Ariadne_GraphDirectedAcyclic.java new file mode 100644 index 0000000..3a8e9e2 --- /dev/null +++ b/developer/javac/Ariadne_GraphDirectedAcyclic.java @@ -0,0 +1,214 @@ +package com.ReasoningTechnology.Ariadne; + +import java.util.HashMap; +import java.util.Map; +import java.util.List; +import java.util.ArrayList; + +public class Ariadne_GraphDirectedAcyclic extends Ariadne_Graph { + + /*-------------------------------------------------------------------------------- + Constructors + */ + + public Ariadne_GraphDirectedAcyclic(Map node_map, Ariadne_ProductionList recognizer_f_list, Ariadne_LabelList root_node_list, int max_depth, boolean verbose) { + super(node_map, recognizer_f_list); + Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list, max_depth, verbose); + } + + public Ariadne_GraphDirectedAcyclic(Map node_map, Ariadne_ProductionList recognizer_f_list, Ariadne_LabelList root_node_list) { + super(node_map, recognizer_f_list); + Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list); + } + + /*-------------------------------------------------------------------------------- + Instance Data Extension + */ + + private static boolean debug = true; + + /*-------------------------------------------------------------------------------- + Interface + */ + + private List path_find_cycle(Ariadne_LabelList path) { + if (path.size() <= 1) return null; + + int rightmost_index = path.size() - 1; + Ariadne_Label rightmost_node_label = path.get(rightmost_index); + + int cycle_leftmost_index = path.indexOf(rightmost_node_label); + Boolean has_cycle = cycle_leftmost_index < rightmost_index; + if (!has_cycle) return null; + + List result = new ArrayList<>(); + result.add(cycle_leftmost_index); + result.add(rightmost_index); + return result; + } + + private boolean graph_descend_cycle_case(Ariadne_LabelList left_path, List path_stack, boolean verbose) { + + List cycle_index_interval = path_find_cycle(left_path); + if (cycle_index_interval == null) { + return false; + } + + int cycle_i0 = cycle_index_interval.get(0); + int cycle_n = cycle_index_interval.get(1); + + if (verbose) Ariadne_Util.print_list( + "Found cycle:", + left_path.subList(cycle_i0, cycle_n + 1) + ); + + Ariadne_LabelList undefined_node_list = new Ariadne_LabelList(); + for (int i = cycle_i0; i <= cycle_n; i++) { + Ariadne_Label node_label = left_path.get(i); + Ariadne_Node node = super.lookup(node_label); + if (node != null) { + node.mark(new Ariadne_Token("cycle_member")); + } else { + undefined_node_list.add(node_label); + } + } + + if (verbose) Ariadne_Util.print_list( + "Each undefined node could not be marked as a cycle member:", + undefined_node_list + ); + + path_stack.subList(cycle_i0 + 1, cycle_n + 1).clear(); + + return true; + } + + private static Ariadne_TokenSet graph_descend_set = new Ariadne_TokenSet() {{ + add(new Ariadne_Token("empty_path_stack")); + add(new Ariadne_Token("cycle_found")); + add(new Ariadne_Token("undefined_node")); + add(new Ariadne_Token("leaf")); + add(new Ariadne_Token("max_depth_reached")); + }}; + + private Ariadne_TokenSet graph_descend(List path_stack, int max_depth, boolean verbose) { + Ariadne_TokenSet ret_value = new Ariadne_TokenSet(); + + if (path_stack.isEmpty()) { + ret_value.add(new Ariadne_Token("empty_path_stack")); + return ret_value; + } + + Ariadne_LabelList left_path = new Ariadne_LabelList(); + for (Ariadne_LabelList neighbor_list : path_stack) { + left_path.add(neighbor_list.get(0)); + } + + do { + + if (graph_descend_cycle_case(left_path, path_stack, verbose)) { + ret_value.add(new Ariadne_Token("cycle_found")); + return ret_value; + } + + Ariadne_Label it_node_label = path_stack.get(path_stack.size() - 1).get(0); + Ariadne_Node it_node = super.lookup(it_node_label); + if (it_node == null) { + ret_value.add(new Ariadne_Token("undefined_node")); + return ret_value; + } + + Ariadne_LabelList neighbor_list = it_node.neighbor_LabelList(); + if (neighbor_list.isEmpty()) { + ret_value.add(new Ariadne_Token("leaf")); + return ret_value; + } + + path_stack.add(new Ariadne_LabelList(neighbor_list)); + Ariadne_Label it_next_label = neighbor_list.get(0); + left_path.add(it_next_label); + + if (max_depth > 0) { + max_depth--; + if (max_depth == 0) { + if (verbose) { + Ariadne_Util.print_list("GraphDirectedAcyclic.GraphDescend:: max_depth reached, ending descent:", path_stack); + } + ret_value.add(new Ariadne_Token("max_depth_reached")); + return ret_value; + } + } + + } while (true); + } + + public static Ariadne_TokenSet graph_mark_cycles_set = new Ariadne_TokenSet() {{ + add(new Ariadne_Token("empty_root_label_list")); + add(new Ariadne_Token("cycle_exists")); + add(new Ariadne_Token("undefined_node_exists")); + add(new Ariadne_Token("bad_descent_termination")); + add(new Ariadne_Token("max_depth_reached")); + }}; + + public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList, int max_depth, boolean verbose) { + Ariadne_TokenSet ret_value = new Ariadne_TokenSet(); + boolean exists_malformed = false; + Ariadne_TokenSet result; + + if (root_node_LabelList.isEmpty()) { + ret_value.add(new Ariadne_Token("empty_root_label_list")); + return ret_value; + } + + List path_stack = new ArrayList<>(); + path_stack.add(new Ariadne_LabelList(root_node_LabelList)); + + do { + result = graph_descend(path_stack, max_depth, verbose); + if (result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("cycle_exists")); + if (result.contains(new Ariadne_Token("undefined_node"))) ret_value.add(new Ariadne_Token("undefined_node_exists")); + if (result.contains(new Ariadne_Token("max_depth_reached"))) ret_value.add(new Ariadne_Token("max_depth_reached")); + if (!result.contains(new Ariadne_Token("leaf")) && !result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("bad_descent_termination")); + + Ariadne_LabelList top_list = path_stack.get(path_stack.size() - 1); + top_list.remove(0); + if (top_list.isEmpty()) path_stack.remove(path_stack.size() - 1); + + } while (!path_stack.isEmpty()); + + if (verbose) { + if (ret_value.contains("bad_descent_termination")) { + System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: terminated with unexpected condition."); + } + if (ret_value.contains("cycle_exists")) { + System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: One or more cycles detected."); + } + if (ret_value.contains("undefined_node_exists")) { + System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: Undefined nodes exist."); + } + } + + return ret_value; + } + + public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList) { + return graph_mark_cycles(root_node_LabelList, this.debug ? 40 : -1, this.debug); + } + + @Override + public Ariadne_Node lookup(Ariadne_Label node_label, boolean verbose) { + Ariadne_Node node = super.lookup(node_label, verbose); + if (node != null && node.has_mark(new Ariadne_Token("cycle_member"))) { + if (verbose) { + System.out.println("GraphDirectedAcyclic.lookup:: Node is part of a cycle, not returned: " + node_label); + } + return null; + } + return node; + } + + public Ariadne_Node lookup(Ariadne_Label node_label) { + return lookup(node_label, this.debug); + } + +} diff --git a/developer/javac/Ariadne_Label.java b/developer/javac/Ariadne_Label.java new file mode 100644 index 0000000..9f10fcb --- /dev/null +++ b/developer/javac/Ariadne_Label.java @@ -0,0 +1,42 @@ +package com.ReasoningTechnology.Ariadne; + +/* + A value for the node.label property. + + This is a wrapper for a String. We can't instead use an alias by extending + String, because String is a JavaScript 'final' type. + +*/ +public class Ariadne_Label{ + private final String value; + + public Ariadne_Label(String value){ + this.value = value; + } + + public boolean isEmpty(){ + return value.isEmpty(); + } + + public String get(){ + return value; + } + + @Override + public String toString(){ + return value; + } + + @Override + public boolean equals(Object o){ + if(this == o) return true; + if( o == null || getClass() != o.getClass() ) return false; + Ariadne_Label label = (Ariadne_Label)o; + return value.equals( label.value ); + } + + @Override + public int hashCode(){ + return value.hashCode(); + } +} diff --git a/developer/javac/Ariadne_LabelList.java b/developer/javac/Ariadne_LabelList.java new file mode 100644 index 0000000..ae2dd0b --- /dev/null +++ b/developer/javac/Ariadne_LabelList.java @@ -0,0 +1,18 @@ +// LabelList.java +package com.ReasoningTechnology.Ariadne; +import java.util.List; +import java.util.ArrayList; + +public class Ariadne_LabelList extends ArrayList{ + // Constructor + public Ariadne_LabelList(){ + super(); + } + public Ariadne_LabelList(List labels){ + super(); // Initialize the parent class + if(labels != null){ + this.addAll(labels); // Copy all elements from the provided list + } + } + +} diff --git a/developer/javac/Ariadne_Node.java b/developer/javac/Ariadne_Node.java new file mode 100644 index 0000000..41d8ccd --- /dev/null +++ b/developer/javac/Ariadne_Node.java @@ -0,0 +1,30 @@ +package com.ReasoningTechnology.Ariadne; +import java.util.HashMap; + +public class Ariadne_Node extends HashMap { + + private static String mark_property_name = "mark"; + private static String neighbor_property_name = "neighbor"; + + public Ariadne_Node() { + super(); + this.put(neighbor_property_name, new Ariadne_LabelList()); + } + + public void mark(Ariadne_Token token) { + if (this.get(mark_property_name) == null) { + this.put(mark_property_name, new Ariadne_TokenSet()); + } + ((Ariadne_TokenSet) this.get(mark_property_name)).add(token); + } + + public boolean has_mark(Ariadne_Token token) { + Ariadne_TokenSet mark = (Ariadne_TokenSet) this.get(mark_property_name); + return mark != null && mark.contains(token); + } + + public Ariadne_LabelList neighbor_LabelList() { + return (Ariadne_LabelList) this.get(neighbor_property_name); + } + +} diff --git a/developer/javac/Ariadne_NodeList.java b/developer/javac/Ariadne_NodeList.java new file mode 100644 index 0000000..69e4284 --- /dev/null +++ b/developer/javac/Ariadne_NodeList.java @@ -0,0 +1,10 @@ +// NodeList.java +package com.ReasoningTechnology.Ariadne; +import java.util.ArrayList; + +public class Ariadne_NodeList extends ArrayList { + // Constructor + public Ariadne_NodeList(){ + super(); + } +} diff --git a/developer/javac/Ariadne_Production.java b/developer/javac/Ariadne_Production.java new file mode 100644 index 0000000..ab6aed9 --- /dev/null +++ b/developer/javac/Ariadne_Production.java @@ -0,0 +1,5 @@ +// Production.java +package com.ReasoningTechnology.Ariadne; +import java.util.function.Function; + +public interface Ariadne_Production extends Function {} diff --git a/developer/javac/Ariadne_ProductionList.java b/developer/javac/Ariadne_ProductionList.java new file mode 100644 index 0000000..03b2461 --- /dev/null +++ b/developer/javac/Ariadne_ProductionList.java @@ -0,0 +1,10 @@ +// ProductionList.java +package com.ReasoningTechnology.Ariadne; +import java.util.ArrayList; + +public class Ariadne_ProductionList extends ArrayList { + // Constructor + public Ariadne_ProductionList(){ + super(); + } +} diff --git a/developer/javac/Ariadne_Token.java b/developer/javac/Ariadne_Token.java new file mode 100644 index 0000000..98e3863 --- /dev/null +++ b/developer/javac/Ariadne_Token.java @@ -0,0 +1,35 @@ +package com.ReasoningTechnology.Ariadne; + +/* +An error token. + +*/ +public class Ariadne_Token { + private final String value; + + public Ariadne_Token(String value){ + this.value = value; + } + + public String get(){ + return value; + } + + @Override + public String toString(){ + return value; + } + + @Override + public boolean equals(Object o){ + if(this == o) return true; // No padding, not nested + if( o == null || getClass() != o.getClass() ) return false; // Padded, because it's nested + Ariadne_Token token = (Ariadne_Token)o; + return value.equals( token.value ); + } + + @Override + public int hashCode(){ + return value.hashCode(); + } +} diff --git a/developer/javac/Ariadne_TokenSet.java b/developer/javac/Ariadne_TokenSet.java new file mode 100644 index 0000000..9ec671c --- /dev/null +++ b/developer/javac/Ariadne_TokenSet.java @@ -0,0 +1,10 @@ +// TokenSet.java +package com.ReasoningTechnology.Ariadne; +import java.util.HashSet; + +public class Ariadne_TokenSet extends HashSet { + // Constructor + public Ariadne_TokenSet(){ + super(); + } +} diff --git a/developer/javac/Ariadne_Util.java b/developer/javac/Ariadne_Util.java new file mode 100644 index 0000000..28009b3 --- /dev/null +++ b/developer/javac/Ariadne_Util.java @@ -0,0 +1,25 @@ +package com.ReasoningTechnology.Ariadne; +import java.util.List; + +public class Ariadne_Util{ + static boolean debug = false; + + public static void print_list(String prefix ,List item_list){ + if( item_list == null || item_list.isEmpty() ){ + return; + } + if( prefix != null && !prefix.isEmpty() ){ + System.out.print(prefix); + } + int i = 0; + int n = item_list.size() - 1; + System.out.print( " '" + item_list.get(i) + "'" ); + do{ + i++; + if( i > n ) break; + System.out.print(", " + "'" + item_list.get(i) + "'"); + }while( true ); + System.out.println("."); + } + +} diff --git a/developer/javac/File.java b/developer/javac/File.java deleted file mode 100644 index 4058dc7..0000000 --- a/developer/javac/File.java +++ /dev/null @@ -1,76 +0,0 @@ -package com.ReasoningTechnology.Ariadne; - -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.List; -import com.ReasoningTechnology.Mosaic.Mosaic_IO; - -public class File { - static boolean debug = false; - - public static Map unpack_file_path(String file_fp) { - if (debug) System.out.println("unpack_file_path::file_fp: " + file_fp); - - // Use java.io.File explicitly to avoid conflict with the custom File class - java.io.File file = new java.io.File(file_fp); - String parent_dp = (file.getParent() != null) ? file.getParent() : ""; - - if (!parent_dp.isEmpty() && !parent_dp.endsWith(java.io.File.separator)) { - parent_dp += java.io.File.separator; - } - - String file_fn = file.getName(); - String file_fn_base = file_fn; - String file_fn_ext = ""; - - int last_index = file_fn.lastIndexOf('.'); - if (last_index > 0) { - file_fn_base = file_fn.substring(0, last_index); - if (last_index + 1 < file_fn.length()) { - file_fn_ext = file_fn.substring(last_index + 1); - } - } - - Map ret_val = new HashMap<>(); - ret_val.put("dp", parent_dp); - ret_val.put("fn", file_fn); - ret_val.put("fn_base", file_fn_base); - ret_val.put("fn_ext", file_fn_ext); - - if (debug) System.out.println("unpack_file_path::ret_val: " + ret_val); - - return ret_val; - } - - public static boolean file_exists_q(String fp_string) { - Path fp_object = Paths.get(fp_string); - return Files.exists(fp_object); - } - - /* - Given a target_fp and a list of list of dependency_fp. - - Returns false if either the target is newer than all the dependencies, or one - of the specified files is missing. Otherwise returns true. - */ - public static boolean newer_than_all(String target_fp_string, List dependency_fp_list) throws IOException { - Path target_fp_object = Paths.get(target_fp_string); - if (!Files.exists(target_fp_object)) return false; - - long target_last_modified_time = Files.getLastModifiedTime(target_fp_object).toMillis(); - - return dependency_fp_list.stream().allMatch(dependency_fp -> { - try { - Path dependency_fp_object = Paths.get(dependency_fp); - if (!Files.exists(dependency_fp_object)) return false; - long dependency_last_modified_time = Files.getLastModifiedTime(dependency_fp_object).toMillis(); - return target_last_modified_time > dependency_last_modified_time; - } catch (IOException e) { - return false; - } - }); - } - -} diff --git a/developer/javac/Graph.java b/developer/javac/Graph.java deleted file mode 100644 index d50c429..0000000 --- a/developer/javac/Graph.java +++ /dev/null @@ -1,63 +0,0 @@ -package com.ReasoningTechnology.Ariadne; - -import java.util.HashMap; -import java.util.Map; - -public class Graph{ - - /*-------------------------------------------------------------------------------- - constructors - */ - - public Graph(Map