Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package it.unibz.krdb.obda.owlrefplatform.core.reformulation;
  
  /*
   * #%L
   * ontop-reformulation-core
   * %%
   * Copyright (C) 2009 - 2014 Free University of Bozen-Bolzano
   * %%
   * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * #L%
  */
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 public class TreeWitnessSet {
 	private List<TreeWitnesstws = new LinkedList<TreeWitness>();
 	private final QueryConnectedComponent cc;
 	private final TreeWitnessReasonerLite reasoner;
 	private boolean hasConflicts = false;
 	
 	// working lists (may all be nulls)
 	private Queue<TreeWitnessdelta;
 
 	private static final Logger log = LoggerFactory.getLogger(TreeWitnessSet.class);
 	
 		this. = cc;
 		this. = reasoner;
 	}
 	
 	public Collection<TreeWitnessgetTWs() {
 		return ;
 	}
 	
 	public boolean hasConflicts() {
 		return ;
 	}
 	
 		TreeWitnessSet treewitnesses = new TreeWitnessSet(ccreasoner);
 		
 		if (!cc.isDegenerate())
 			treewitnesses.computeTreeWitnesses();
 				
 		return treewitnesses;
 	}
 
 	private void computeTreeWitnesses() {		
 		QueryFolding qf = new QueryFolding(); // in-place query folding, so copying is required when creating a tree witness
 		
 		for (Loop loop : .getQuantifiedVariables()) {
 			Term v = loop.getTerm();
 			.debug("QUANTIFIED VARIABLE {}"v); 
 			
 			for (Edge edge : .getEdges()) { // loop.getAdjacentEdges()
 				if (edge.getTerm0().equals(v)) {
 					if (!qf.extend(edge.getLoop1(), edgeloop))
 						break;
 				}
 				else if (edge.getTerm1().equals(v)) {
					if (!qf.extend(edge.getLoop0(), edgeloop))
						break;
				}
			}
			if (qf.isValid()) {
				// tws cannot contain duplicates by construction, so no caching (even negative)
				if (twg != null) { 
					// no need to copy the query folding: it creates all temporary objects anyway (including NewLiterals)
				}
			}
		}		
		if (!.isEmpty()) {
			Queue<TreeWitnessworking = new LinkedList<TreeWitness>();
			for (TreeWitness tw : 
				if (tw.isMergeable())  {
					working.add(tw);			
				}
			while (!working.isEmpty()) {
				while (!working.isEmpty()) {
					TreeWitness tw = working.poll(); 
				}
				while (!.isEmpty()) {
					addTWS(tw);
					if (tw.isMergeable())  {
						working.add(tw);			
					}
				}
			}				
		}
		.debug("TREE WITNESSES FOUND: {}".size());
	}
	private void addTWS(TreeWitness tw1) {
		for (TreeWitness tw0 : )
			if (!tw0.getDomain().containsAll(tw1.getDomain()) && !tw1.getDomain().containsAll(tw0.getDomain())) {
				if (!TreeWitness.isCompatible(tw0tw1)) {
					 = true;
					.debug("CONFLICT: {}  AND {}"tw0tw1);
				}
			}
		.add(tw1);
	}
	private void saturateTreeWitnesses(QueryFolding qf) { 
		boolean saturated = true
		for (Edge edge : .getEdges()) { 
			Loop rootLoopinternalLoop;
			if (qf.canBeAttachedToAnInternalRoot(edge.getLoop0(), edge.getLoop1())) {
				rootLoop = edge.getLoop0();
				internalLoop = edge.getLoop1();
			}
			else if (qf.canBeAttachedToAnInternalRoot(edge.getLoop1(), edge.getLoop0())) { 
				rootLoop = edge.getLoop1();
				internalLoop = edge.getLoop0();
			}
			else
				continue;
			.debug("EDGE {} IS ADJACENT TO THE TREE WITNESS {}"edgeqf); 
			if (qf.getRoots().contains(internalLoop)) {
				if (qf.extend(internalLoopedgerootLoop)) {
					.debug("    RE-ATTACHING A HANDLE {}"edge);
					continue;
				}	
				else {
					.debug("    FAILED TO RE-ATTACH A HANDLE {}"edge);
					return;					
				}
			}
			saturated = false
			Term rootNewLiteral = rootLoop.getTerm();
			Term internalNewLiteral = internalLoop.getTerm();
			for (TreeWitness tw : )  
				if (tw.getRoots().contains(rootNewLiteral) && tw.getDomain().contains(internalNewLiteral)) {
					.debug("    ATTACHING A TREE WITNESS {}"tw);
			QueryFolding qf2 = new QueryFolding(qf);
			if (qf2.extend(internalLoopedgerootLoop)) {
				.debug("    ATTACHING A HANDLE {}"edge);
			}	
		}
		if (saturated && qf.hasRoot())  {
				if (twg != null) {
					TreeWitness tw = qf.getTreeWitness(twg.getEdges()); 
					.put(tw.getTerms(), tw);
				}
				else
					.put(qf.getTerms(), null); // cache negative
			}
			else {
				.debug("TWS CACHE HIT {}"qf.getTerms());
			}
		}
	}
	// can return null if there are no applicable generators!
		.debug("CHECKING WHETHER THE FOLDING {} CAN BE GENERATED: "qf); 
			Set<Propertysubp = qf.getProperties();
			if ((subp == null) || !subp.contains(g.getProperty())) {
				.debug("      NEGATIVE PROPERTY CHECK {}"g.getProperty());
				continue;
			}
			else
				.debug("      POSITIVE PROPERTY CHECK {}"g.getProperty());
			if ((subc != null) && !g.endPointEntailsAnyOf(subc)) {
				 .debug("        ENDTYPE TOO SPECIFIC: {} FOR {}"subcg);
				 continue;			
			}
			else
				 .debug("        ENDTYPE IS FINE: TOP FOR {}"g);
			boolean failed = false;
					.debug("        ENDTYPE TOO SPECIFIC: {} FOR {}"twg);
					failed = true;
					break;
				else
					.debug("        ENDTYPE IS FINE: {} FOR {}"twg);
			if (failed)
				continue;
			if (twg == null
			twg.add(g);
			.debug("        OK");
		}
		return twg;
	}
	}
		private boolean isInNext[];
		private boolean atNextPosition = true;
		private boolean finished = false;
			 = new boolean[len];
		}

Returns the next subset of tree witnesses

Returns:
the next subset of tree witnesses
Throws:
java.util.NoSuchElementException has no more subsets.
				 = false;
				return ;
			}
			while (!isLast()) 
				if (moveToNext()) {
					 = false;
					return ;
				}
			 = true;
			throw new NoSuchElementException("The next method was called when no more objects remained.");
	    }

  

Returns:
true if the PowerSet has more subsets.
	  	public boolean hasNext() {
				return !;
			while (!isLast()) 
				if (moveToNext()) {
					return true;
				}
			return false;
	  	}
		private boolean isLast() {
	  		for (int i = 0; i < .i++)
	  			if (![i])
	  				return false;
	  		return true;
		}
		// return true if the next is compatible
		private boolean moveToNext() {
		    boolean carry = true;
			for (int i = 0; i < .i++)
				if(!carry)
					break;
				else {
			        carry = [i];
			        [i] = ![i];
				}			
			int i = 0;
	      	for (TreeWitness tw : )
	      		if ([i++]) {
	      			for (TreeWitness tw0 : )
	      				if (!TreeWitness.isCompatible(tw0tw)) 
	      					return false;
	      					
	      			.add(tw);
	      		}
	      	return true;
		}

Throws:
java.lang.UnsupportedOperationException because the remove operation is not supported by this Iterator.
		public void remove() {
			throw new UnsupportedOperationException("The PowerSet class does not support the remove method.");
		}
	}
	static class PropertiesCache {
			this. = reasoner;
		}
			Term t = loop.getTerm();
			if (subconcepts == null) {				
				subconcepts = .getSubConcepts(loop.getAtoms());
				.put(tsubconcepts);	
			}
			return subconcepts;
		}
		public Set<PropertygetEdgeProperties(Edge edgeTerm rootTerm nonroot) {
			TermOrderedPair idx = new TermOrderedPair(rootnonroot);
			Set<Propertyproperties = .get(idx);			
			if (properties == null) {
				for (Function a : edge.getBAtoms()) {
						.debug("EDGE {} HAS PROPERTY {} NO BOOLEAN OPERATION PREDICATES ALLOWED IN PROPERTIES"edgea);
						properties = .;
						break;
					}
				}
				if (properties == null) {
					for (Function a : edge.getBAtoms()) {
						.debug("EDGE {} HAS PROPERTY {}",  edgea);
							break;
					}
					properties = set.get();
				}	
				.put(idxproperties); // edge.getTerms()
			}
			return properties;
		}
	}
	private static class TermOrderedPair {
		private final Term t0t1;
		private final int hashCode;
		public TermOrderedPair(Term t0Term t1) {
			this. = t0;
			this. = t1;
			this. = t0.hashCode() ^ (t1.hashCode() << 4);
		}
		public boolean equals(Object o) {
			if (o instanceof TermOrderedPair) {
				return (this..equals(other.t0) && this..equals(other.t1));
			}
			return false;
		}
		public String toString() {
			return "term pair: (" +  + ", " +  + ")";
		}
		public int hashCode() {
			return ;
		}
	}	
		if (.isDegenerate()) { // do not remove the curly brackets -- dangling else otherwise
			.debug("DEGENERATE DETACHED COMPONENT: {}");
			if (!subc.isEmpty()) // (subc == null) || 
					if ((subc.get() == null) || twg.endPointEntailsAnyOf(subc.get())) {
						.debug("        ENDTYPE IS FINE: {} FOR {}"subctwg);
						generators.add(twg);					
					}
					else 
						 .debug("        ENDTYPE TOO SPECIFIC: {} FOR {}"subctwg);
				}
		else {
			for (TreeWitness tw : 
					.debug("TREE WITNESS {} COVERS THE QUERY",  tw);
					if (!subc.isEmpty())
							if ((subc.get() == null) || twg.endPointEntailsAnyOf(subc.get())) {
								.debug("        ENDTYPE IS FINE: {} FOR {}",  subctwg);
									.debug("        ENDTYPE IS FINE: {} FOR {}",  twtwg);
									generators.add(twg);					
								}
								else  
									.debug("        ENDTYPE TOO SPECIFIC: {} FOR {}"twtwg);
							}
							else 
								 .debug("        ENDTYPE TOO SPECIFIC: {} FOR {}"subctwg);
				}
		}
		if (!generators.isEmpty()) {
			boolean saturated = false;
			while (!saturated) {
				saturated = true;
				for (TreeWitnessGenerator twg : generators
					if (g.endPointEntailsAnyOf(subc)) {
						if (generators.add(g))
							saturated = false;
					}		 		
		}	
		return generators;
	}
New to GrepCode? Check out our FAQ X