[ https://jira.jboss.org/jira/browse/DNA-215?page=com.atlassian.jira.plugin... ] Randall Hauch commented on DNA-215: ----------------------------------- Here is my latest thought on what the DSL might look like when used. (This is in the GraphTest unit test in the patch.) Comments are welcome: // Get all (or some) of the children of a node ... Children children1 = graph.get().children().at(path); Children children2 = graph.get().children().of(path); Children children3 = graph.get().children().of(path).matching(nameMatcher); Children children4 = graph.get().children().matching(nameMatcher).of(path); Children children5 = graph.get().children().having(propertyMatcher).of(path); // Get the values of a single property by iterating ... for (Object value : graph.get().property(name).at(path)) { } for (Object value : graph.get().property(name).on(path)) { } for (Object value : graph.get().property(name).of(path)) { } // Get the properties on a node by iterating ... for (Property property : graph.get().properties().at(path)) { } for (Property property : graph.get().properties().at(path).matching(nameMatcher)) { } for (Property property : graph.get().properties().at(path).matching(nameMatcher)) { } // Get a node (both properties and children) ... Node node1 = graph.get().node().at(path); Node node2 = graph.get().node().with(uuid); Node node3 = graph.get().node().having(uuid); Node node4 = graph.get().node().at(uuid); Node node5 = graph.get().node(path); Node node6 = graph.get().node(uuid); // Work with the properties and children of a previously obtained node... Children children6 = node1.getChildren(); Children children7 = node1.getChildren().having(propertyMatcher); Children children8 = node1.getChildren().matching(nameMatcher); Property prop7 = node1.getProperty(name); MultipleProperties props4 = node1.getProperties(); MultipleProperties props5 = node1.getProperties().having(propertyMatcher); MultipleProperties props6 = node1.getProperties().matching(nameMatcher); // Get a subgraph (nodes and properties) Subgraph subgraph1 = graph.get().subgraph("/a/b"); Subgraph subgraph2 = graph.get().subgraph("/a/b").ofDepth(3); Subgraph subgraph3 = graph.get().subgraph().at("/a/b").ofDepth(3); Subgraph subgraph4 = graph.get().subgraph().at(uuid).ofDepth(3); // Get nodes from within a subgraph ... Node node10 = subgraph1.getRoot(); Node node11 = subgraph1.getNode(relativePath); Node node12 = subgraph1.getNode(uuid); // We can add support for visitors, too // graph.get().subgraph(path).visit(myVisitor); // Then there are operations on a graph that result in changes to the graph. These consist of // copy, delete, move, create, and set. When using these, the graph records the commands but // delays executing (or committing) them against the source until the "commit()" method is called. // // Changes to the graph can be interspersed with "get()" commands. When this happens, it is // up to the graph implementation to define the behavior when the result of a get command // is requested (e.g., the get command is to be executed) while there are uncommitted changes. // Copy a portion of the content in the graph ... graph.copy().node("/a/b/").into("/x/y"); graph.copy().node("/a/b/").into("/x/y").and().get().node("/m/n"); graph.copyNode("/a/b/").into("/x/y"); graph.copy().node().at("/a/b").into("/x/y"); graph.copy().node().with(uuid).into("/x/y"); graph.copy().subgraph("/a/b").into("/x/y"); graph.copy().subgraph().at(uuid).into("/x/y"); graph.copySubgraph("/a/b/").into("/x/y"); graph.copy().children().of(uuid).into("/x/y"); graph.copy().children().matching(nameMatcher).on(uuid).into("/x/y"); graph.copy().children().of(uuid).matching(nameMatcher).into("/x/y"); graph.copy().children().of("/a/b").into("/x/y"); graph.copy().properties().of("/a/b").into("/x/y"); graph.move().node("/a/b/").into("/x/y"); graph.move().node("/a/b/").into("/x/y").and().get().node("/m/n"); graph.move().node().at("/a/b").into("/x/y"); graph.move().node().with(uuid).into("/x/y"); graph.move().properties().of("/a/b").into("/x/y"); graph.move().properties().of("/a/b").matching(nameMatcher).into("/x/y"); graph.move().children().of("/a/b").into("/x/y"); graph.move().children().of(uuid).into("/x/y"); graph.move().children().with(nameMatcher).on(uuid).into("/x/y"); graph.move().children().having(propertyMatcher).on(uuid).into("/x/y"); graph.move().children().matching(nameMatcher).on(uuid).into("/x/y"); graph.move().children().of(uuid).matching(nameMatcher).into("/x/y"); graph.move().properties().matching(nameMatcher).on(uuid).into("/x/y"); graph.move().properties().of(uuid).matching(nameMatcher).into("/x/y"); graph.move().properties().with(nameMatcher).on(uuid).into("/x/y"); graph.move().properties().having(propertyMatcher).on(uuid).into("/x/y"); graph.move().properties().of(uuid).matching(nameMatcher).into("/x/y"); graph.move("/a/b/").into("/x/y").and().getNode("/m/n"); graph.delete().nodes().under(path); graph.delete().nodes().under(path).matching(nameMatcher); graph.delete().nodes().under(path).having(propertyMatcher); graph.delete().node("/a/b"); graph.delete().child(name).on(uuid); graph.delete().child(name, 1).on(uuid); graph.delete().child(pathSegment).on(uuid); graph.delete().children().matching(nameMatcher).on(uuid); graph.delete().children().matching(nameMatcher).on("/a/b"); graph.delete().children().having(propertyMatcher).on("/a/b"); graph.delete().children().of(uuid).matching(nameMatcher); graph.delete().children().of("/a/b").matching(nameMatcher); graph.delete().children().of("/a/b").having(propertyMatcher); graph.delete().property("p1").on("/a/b"); graph.delete().property("p1").on(uuid); graph.delete().property("p1").and().property("p2").on(uuid); graph.delete().properties("p1", "p2").on(uuid); graph.delete().properties().matching(nameMatcher); graph.delete().property().matching(nameMatcher); graph.delete().property("p1").and().children().matching(nameMatcher).on(uuid); graph.delete().node(path).and().delete().node(path); graph.delete().node(path).and(path); graph.delete().nodes(path, path); graph.create().node().at(path).with().property("p1", 1, 2, 3); graph.create().node().at(path).with().property("p1", 1, 2, 3).and("p2", 1); graph.create().node(path).with().property("p1", 1, 2, 3).and("p2", 1); graph.create().node(path).with(uuid).and("p1", 1, 2, 3).and("p2", 1); graph.create().node(path).with("p1", 1, 2, 3).and("p2", 1); graph.create().child(name).under(path).with().property("p1", 1, 2, 3).and("p2", 1); graph.create().child(name, 3).under(path).with().property("p1", 1, 2, 3).and("p2", 1); graph.create().orUpdate().node().at(path).with().property("p1", 1, 2, 3).and("p2", 1); graph.create().node("/a/b").with().property("p1", 1, 2, 3).and("p2", 2); graph.create("/a/b").with().property("p1", 1, 2, 3).and("p2", 2); graph.create("/a/b").with("p1", 1, 2, 3).and("p2", 2); graph.create("/a/b").with("p1", 1, 2, 3).and("p2", 2).and().create("/a/b/c").with(uuid).and("p3", "p3value"); graph.create("/a/b").with(uuid).and("p1", 1, 2, 3).and("p2", 2); graph.create("/a/b").with(uuid).and("p1", 1, 2).and("p2", 2).and().createChild("c").under(path).with().property("p3", 10); graph.create("/a/b").with(uuid).and("p1", 1, 2, 3).and("p2", 2).and().create("/a/b/c").with().property("p3", 10); graph.createChild("c").under("/a/b").with("p1", 1, 2, 3).and("p2", 2); graph.createChild("c/d").under("/a/b").with("p1", 1, 2, 3).and("p2", 2); graph.set().property("p1").on(path).to(1, 2).and().set().property("p2").on("/c/d/"); graph.set().property("p1", 1, 2).on("/a/b").and().set().property("p2").on("/c/d/"); graph.set().property("p1", 1, 2).and("p2", "value").and("p3", "x").on("/a/b").and().set().property("p2").on("/c/d/"); graph.set().property("p1", 1, 2).and("p2").to("value").on("/a/b").and().set().property("p2").on("/c/d/"); graph.set().property("p1").to(1, 2).and("p2").to("value").on("/a/b").and().set().property("p2").on("/c/d/"); graph.set("p1").to(1, 2).on("/a/b").and().set().property("p2").on("/c/d/"); graph.set("p1", 1, 2).on("/a/b").and().set().property("p2").on("/c/d/"); // Changes made via a graph are committed (or executed) using the "commit" method. graph.commit(); -- This message is automatically generated by JIRA. - If you think it was sent incorrectly contact one of the administrators: https://jira.jboss.org/jira/secure/Administrators.jspa - For more information on JIRA, see: http://www.atlassian.com/software/jira

[ https://jira.jboss.org/jira/browse/DNA-215?page=com.atlassian.jira.plugin... ] Randall Hauch commented on DNA-215: ----------------------------------- Created a new API implementation that evolved from the two previous prototypes. This design is actually pretty efficient, since very few intermediate API objects are created (unlike the previous prototypes), and it offers the ability to execute requests immediately (by invoking methods directly on the graph) or to batch together multiple requests (by first using Graph.batch() to obtain a batch, then adding various requests to the batch, and finally executing the batch to obtain the batch results. Like the previous designs, this API uses an internal DSL approach to make the code that uses the API more readable, and to rely upon returned interfaces to help guide the developer (especially when they have code-completion in their IDE). Method chaining is also possible with this design. Here are a few simple examples of using this new API: for ( Property property : graph.getProperties().on("/a/b") ) { ... } for ( Location child : graph.getChildren().of("/a/b") ) { ... } Node node = graph.getNodeAt("/a/b"); Subgraph subgraph = graph.getSubgraphOfDepth(3).at("/c/d"); graph.delete("/a/b/c").and().move(uuid).into(path1); graph.create("/a/b/c/d", property1, property2, property3); Obviously this is just a sample, but it shows the main intent of the design. Notice that these operations are invoked directly on the graph (which is returned by the "and()" method, allowing methods to be chained). These operations are executed immediately upon completion, and the read methods return their results immediately. It's also possible to do similar operations in batches: graph.batch().delete("/a/b/c"). and().move(uuid).into(path1). and().create("/a/b/c/d", property1, property2, property3).execute(); Here, all 3 requests (1 delete, 1 move, and 1 create) are submitted to the repository source in a single CompositeRequest when the "execute()" method is called. It is possible to read information, too, but the results must be fetched after execution: Results results = graph.batch().delete("/a/b/c"). and().move(uuid).into(path1). and().create("/a/b/c/d", property1, property2, property3). and().read("/j/k/m").and().readSubgraphOfDepth(3).at("/x/y").execute(); Node jkm = results.getNode("/j/k/m"); for ( Location child : jkm.getChildren() ) { ... } Node xy = results.getNode("/x/y"); for ( Location child : xy ) { for ( Property prop : child.getProperties() ) {...} } Again, these samples just show a few of the things that are possible. For more information, see the org.jboss.dna.graph.Graph class (as well as its test case). -- This message is automatically generated by JIRA. - If you think it was sent incorrectly contact one of the administrators: https://jira.jboss.org/jira/secure/Administrators.jspa - For more information on JIRA, see: http://www.atlassian.com/software/jira

[ https://jira.jboss.org/jira/browse/DNA-215?page=com.atlassian.jira.plugin... ] Randall Hauch resolved DNA-215. ------------------------------- Resolution: Done The graph API seems to work really well. Some uses of the older GraphCommands were replaced with uses of the new Graph API; all other uses of the old GraphCommands were replaced with the new Requests. -- This message is automatically generated by JIRA. - If you think it was sent incorrectly contact one of the administrators: https://jira.jboss.org/jira/secure/Administrators.jspa - For more information on JIRA, see: http://www.atlassian.com/software/jira