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.Set;
 
 
 public class QueryFolding {
 	private final PropertiesCache propertiesCache;
 	
 	private Set<Looproots
 	private Set<TerminternalRoots;
 	private Set<TerminternalDomain;
 	private List<TreeWitnessinterior;
 	private boolean status;
 
 	private static final Logger log = LoggerFactory.getLogger(QueryFolding.class);
 		
 	public String toString() {
 		return "Query Folding: " +  + ", internal roots " +  + " and domain: " +  + " with properties: " + 
 	}
 	
 	public QueryFolding(PropertiesCache propertiesCache) {
 		this. = propertiesCache;
 		 = new HashSet<Loop>(); 
 		 = new HashSet<Term>();
 		 = new HashSet<Term>();
 		 = .// in-place QueryFolding for one-step TreeWitnesses, 
 		                                   //             which have no interior TreeWitnesses
 		 = true;
 	}
 	
 	public QueryFolding(QueryFolding qf) {
 		this. = qf.propertiesCache;
 
 		 = new IntersectionOfProperties(qf.properties.get()); 
 		 = new HashSet<Loop>(qf.roots); 
 		 = new IntersectionOfConceptSets(qf.internalRootConcepts.get()); 
 		 = new HashSet<Term>(qf.internalRoots);
 		 = new HashSet<Term>(qf.internalDomain);
 		 = new LinkedList<TreeWitness>(qf.interior);
 		 = qf.status;
 	}
 
 	
 	public QueryFolding extend(TreeWitness tw) {
 		assert ();
 		QueryFolding c = new QueryFolding(this);
 		c.internalRoots.addAll(tw.getRoots());
 		c.internalDomain.addAll(tw.getDomain());
 		c.interior.add(tw);
 		if (!c.internalRootConcepts.intersect(tw.getRootConcepts()))
 			c.status = false;
 		return c;
 	}
 	
 	public boolean extend(Loop rootEdge edgeLoop internalRoot) {
 		assert();
		if (.intersect(.getEdgeProperties(edgeroot.getTerm(), internalRoot.getTerm()))) 
				.add(root);
				return true;
			}
		 = false;
		return false;
	}
	public void newOneStepFolding(Term t) {
		 = Collections.singleton(t);
		 = null;
		 = true;		
	}
	public void newQueryFolding(TreeWitness tw) {
		 = null;
		 = true;		
	}
	public Set<PropertygetProperties() {
		return .get();
	}
	public boolean isValid() {
		return ;
	}
	public Set<LoopgetRoots() {
		return ;
	}
	public boolean hasRoot() { 
		return !.isEmpty();
	}
	public boolean canBeAttachedToAnInternalRoot(Loop t0Loop t1) {
		return .contains(t0.getTerm()) && !.contains(t1.getTerm()); // && !roots.contains(t1);
	}
	}
		return ;
	}
		if ( == null) {
			Set<Termdomain = new HashSet<Term>();
			Set<TermrootNewLiterals = new HashSet<Term>();
			for (Loop l : )
				rootNewLiterals.add(l.getTerm());
			domain.addAll(rootNewLiterals);
			 = new TreeWitness.TermCover(domainrootNewLiterals);
		}
		return ;
	}
		.debug("NEW TREE WITNESS");
		.debug("  PROPERTIES {}");
		.debug("  ENDTYPE {}");
		Set<FunctionrootAtoms = new HashSet<Function>();
		for (Loop root : ) {
			rootAtoms.addAll(root.getAtoms());
			if (!root.isExistentialVariable()) { // if the variable is not quantified -- not mergeable
				.debug("  NOT MERGEABLE: {} IS NOT QUANTIFIED"root);				
			}
		}
		// EXTEND ROOT ATOMS BY ALL-ROOT EDGES
		for (Edge edge : edges) {
			if (.contains(edge.getLoop0()) && .contains(edge.getLoop1())) {
				rootAtoms.addAll(edge.getBAtoms());
				.debug("  NOT MERGEABLE: {} IS WITHIN THE ROOTS"edge);				
			}
		}
		.debug("  ROOTTYPE {}"rootAtoms);
		if (rootType.get() == null// not empty 
			for (Loop root : ) {
				if (!rootType.intersect(.getLoopConcepts(root))) { // empty intersection -- not mergeable
					.debug("  NOT MERGEABLE: EMPTY ROOT CONCEPT");
					break;
				}
			}
		return new TreeWitness(twggetTerms(), rootAtomsrootType); 	
	}
New to GrepCode? Check out our FAQ X