public TimeInterval getIntersection(TimeInterval interval, NowReference now) throws Exception { if( !this.intersectsWith(interval, now) ){ return null; }; if( this.isIncludedIn(interval, now) ) { return this; } else if(interval.isIncludedIn(this, now)) { return interval; } else { long min = this.min; long max = this.getMax(now); if( min < interval.min ){ min = interval.min; }; if( max > interval.getMax(now) ){ max = interval.max; }; return new TimeInterval(min,max); } }
@Override public void extendTo(TimeInterval interval) throws Exception { this.interval = this.interval.extendTo(interval); }
public TreeNodeRegular(int clusterId, TimeInterval interval) throws Exception { this.clusterId = clusterId; this.interval = interval; if( interval.isOngoing() ) { throw new Exception("Must be providing a regular time interval"); } else { this.mid = (long)(interval.getMin() + interval.getMax(null)) / (long)2; } }
if( false == elemInt.isIncludedIn(this.interval, now) ){ interval = interval.extendTo( elemInt ); result.setTreeModified(true); if( elemInt.getMax(now) <= this.getMidPoint() && null != this.getLowChildNode() ){ this.getLowChildNode().insertElement(element, result, operations, now); } else if( elemInt.getMin() >= this.getMidPoint() && null != this.getHighChildNode() ){ this.getHighChildNode().insertElement(element, result, operations, now); && elemInt.getMax(now) <= this.getMidPoint() ){ int count = 1; List<TreeElement> nodeElements = operations.getElementsForClusterId(this.getClusterId()); for(TreeElement nodeElement : nodeElements){ if( nodeElement.getInterval().getMax(now) <= this.getMidPoint() ){ ++count; && elemInt.getMin() >= this.getMidPoint() ){ int count = 1; List<TreeElement> nodeElements = operations.getElementsForClusterId(this.getClusterId()); for(TreeElement nodeElement : nodeElements){ if( nodeElement.getInterval().getMin() >= this.getMidPoint() ){ ++count;
if( element.getInterval().isOngoing() ){ if( null == fullOngoingInterval ){ fullOngoingInterval = element.getInterval(); } else { fullOngoingInterval = fullOngoingInterval.extendTo(element.getInterval()); fullRegularInterval = element.getInterval(); } else { fullRegularInterval = fullRegularInterval.extendTo(element.getInterval()); if( elementInterval.isOngoing() ){ TreeNodeOngoing legacyNode = legacyOngoingNodes.get(clusterId); if( null == legacyNode ){ fullRegularInterval = new TimeInterval(0, 1500000000000L); fullOngoingInterval = new TimeInterval(0, (NowReference)null);
if( false == elemInt.isIncludedIn(this.interval, now) ){ interval = interval.extendTo( elemInt ); result.setTreeModified(true); if( elemInt.getMin() <= this.getMidPoint() && null != this.getLowChildNode() ){ this.getLowChildNode().insertElement(element, result, operations, now); } else if( elemInt.getMin() > this.getMidPoint() && null != this.getHighChildNode() ){ this.getHighChildNode().insertElement(element, result, operations, now); && elemInt.getMin() <= this.getMidPoint() ){ List<TreeElement> nodeElements = operations.getElementsForClusterId(this.getClusterId()); int count = nodeElements.size(); && elemInt.getMin() > this.getMidPoint() ){ List<TreeElement> nodeElements = operations.getElementsForClusterId(this.getClusterId()); int count = nodeElements.size();
results.intervalCount++; if( null != docId && null != jsonInterval ){ TimeInterval docInterval = TimeInterval.fromJson(jsonInterval); if( docInterval.intersectsWith(interval, now) ){ DocumentWithInterval docWithInt = new DocumentWithInterval(docId, docInterval); results.documentWithIntervals.add(docWithInt);
public TreeNodeOngoing(int clusterId, long min, long mid) throws Exception { this.clusterId = clusterId; this.interval = new TimeInterval(min, (NowReference)null); this.mid = mid; }
static private void nodeToInfo(TreeNode node, TreeInfo treeInfo, int depth) throws Exception { treeInfo.nodeCount++; if( treeInfo.maxDepth < depth ){ treeInfo.maxDepth = depth; } if( node.getInterval().isOngoing() ) { ++treeInfo.ongoingNodeCount; } else { ++treeInfo.regularNodeCount; if( treeInfo.minInterval > node.getInterval().getSize(null) ){ treeInfo.minInterval = node.getInterval().getSize(null); } } if( null != node.getLowChildNode() ){ nodeToInfo(node.getLowChildNode(), treeInfo, depth+1); } if( null != node.getHighChildNode() ){ nodeToInfo(node.getHighChildNode(), treeInfo, depth+1); } }
TimeInterval timeInterval = TimeInterval.fromJson(jsonInterval);
/** * Find all nodes that intersect with the given interval and accumulate the * node identifiers (cluster ids) in a provided list. * @param interval Interval that is requested * @param clusterIds List of cluster ids that match the given interval * @throws Exception */ @Override public void accumulateClusterIdsFromInterval( TimeInterval interval, List<Integer> clusterIds, NowReference now) throws Exception { if( this.interval.intersectsWith(interval, now) ){ clusterIds.add(this.clusterId); if( null != lowChildNode ){ lowChildNode.accumulateClusterIdsFromInterval(interval, clusterIds, now); } if( null != highChildNode ){ highChildNode.accumulateClusterIdsFromInterval(interval, clusterIds, now); } } }
static public void treeToInfo(Tree tree, PrintWriter pw) throws Exception { TreeInfo treeInfo = new TreeInfo(); if( null != tree.getRegularRootNode() ){ treeInfo.minInterval = tree.getRegularRootNode().getInterval().getSize(null); } else { treeInfo.minInterval = 0; } treeInfo.legacyNodeCount = tree.getLegacyNodes().size(); if( null != tree.getRegularRootNode() ){ nodeToInfo(tree.getRegularRootNode(), treeInfo, 1); } if( null != tree.getOngoingRootNode() ){ nodeToInfo(tree.getOngoingRootNode(), treeInfo, 1); } pw.println("Node count: "+treeInfo.nodeCount); pw.println("Regular node count: "+treeInfo.regularNodeCount); pw.println("On-going node count: "+treeInfo.ongoingNodeCount); pw.println("Legacy node count: "+treeInfo.legacyNodeCount); pw.println("Max node depth: "+treeInfo.maxDepth); pw.println("Full interval: "+tree.getRegularRootNode().getInterval()); pw.println("Min interval size: "+treeInfo.minInterval); }
/** * Modifies a cluster tree as a result of adding a new elements in the * tree. * @param tree Tree where the element is inserted. * @param elements Elements to be inserted in the tree * @return Results of inserting the elements * @throws Exception */ static public Result insertElements(Tree tree, List<TreeElement> elements, NowReference now) throws Exception { ResultImpl result = new ResultImpl(tree); TreeNodeRegular regularRootNode = tree.getRegularRootNode(); TreeNodeOngoing ongoingRootNode = tree.getOngoingRootNode(); for(TreeElement element : elements){ TimeInterval elementInterval = element.getInterval(); if( elementInterval.isOngoing() ){ ongoingRootNode.insertElement(element, result, tree.getOperations(), now); } else { regularRootNode.insertElement(element, result, tree.getOperations(), now); } } return result; } }
@Override public SearchResults getDateIntervalsIntersectingWith(TimeInterval range, NowReference now) throws Exception { SearchResults results = new SearchResults(); CouchQuery query = new CouchQuery(); query.setViewName("date-index"); query.setIncludeDocs(false); query.setReduce(false); CouchQueryResults queryResults = atlasDesignDocument.performQuery(query); results.documentWithIntervals = new ArrayList<DocumentWithInterval>(queryResults.getRows().size()); for(JSONObject row : queryResults.getRows()){ String docId = row.optString("id"); JSONObject jsonInterval = row.optJSONObject("value"); results.intervalCount++; if( null != docId && null != jsonInterval ){ TimeInterval interval = TimeInterval.fromJson(jsonInterval); if( interval.intersectsWith(range, now) ){ DocumentWithInterval docWithInt = new DocumentWithInterval(docId, interval); results.documentWithIntervals.add(docWithInt); results.intervalMatched++; } } } return results; } }
public TreeNodeRegular(int clusterId, long min, long max, long mid) throws Exception { this.clusterId = clusterId; this.interval = new TimeInterval(min, max); this.mid = mid; }
TimeInterval timeInterval = TimeInterval.fromJson(jsonInterval);
/** * Find all nodes that intersect with the given interval and accumulate the * node identifiers (cluster ids) in a provided list. * @param interval Interval that is requested * @param clusterIds List of cluster ids that match the given interval * @throws Exception */ @Override public void accumulateClusterIdsFromInterval( TimeInterval interval, List<Integer> clusterIds, NowReference now) throws Exception { if( this.interval.intersectsWith(interval, now) ){ clusterIds.add(this.clusterId); if( null != lowChildNode ){ lowChildNode.accumulateClusterIdsFromInterval(interval, clusterIds, now); } if( null != highChildNode ){ highChildNode.accumulateClusterIdsFromInterval(interval, clusterIds, now); } } }