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;
 
QueryConnectedComponent represents a connected component of a CQ keeps track of variables (both quantified and free) and edges a connected component can either be degenerate (if it has no proper edges, i.e., just a loop)

Author(s):
Roman Kontchakov
 
 
 public class QueryConnectedComponent {
 
 	private List<Termvariables
 	private List<LoopquantifiedVariables;   
 	private List<TermfreeVariables;
 	
 	private final List<Edgeedges;  // a connect component contains a list of edges 
 	private final Loop loop;  //                                   or a loop if it is degenerate 
 	
 	private final List<FunctionnonDLAtoms;
 	
 	private boolean noFreeTerms// no free variables and no constants 
 	                             // if true the component can be mapped onto the anonymous part of the canonical model
 
 	private static final Logger log = LoggerFactory.getLogger(QueryConnectedComponent.class);

constructor is private as instances created only by the static method getConnectedComponents

Parameters:
edges: a list of edges in the connected component
loop: a loop if the component is degenerate
nonDLAtoms: a list of non-DL atoms in the connected component
terms: terms that are covered by the edges
 
 	
 	private QueryConnectedComponent(List<EdgeedgesList<FunctionnonDLAtomsList<Loopterms) {
 		this. = edges;
 		this. = nonDLAtoms;
 
 		this. = isDegenerate() ? terms.get(0) : null
 				
 		 = new ArrayList<Loop>(terms.size());
 		 = new ArrayList<Term>(terms.size());
 		 = new ArrayList<Term>(terms.size());
 		 = true;
 		
 		for (Loop lterms) {
 			Term t = l.getTerm(); 
 			if (t instanceof Variable) {
 				//if (headNewLiterals.contains(t))
 				else 
 					{
					 = false;
				}
			}
			else
				 = false// not a variable -- better definition?
		}
	}
	public static Loop getLoop(Term tMap<TermLoopallLoopsSet<TermheadTerms) {
		Loop l = allLoops.get(t);
		if (l == null) {
			boolean isExistentialVariable =  ((t instanceof Variable) && !headTerms.contains(t));
			l = new Loop(tisExistentialVariable);
			allLoops.put(tl);
		}
		return l;
	}
	private static QueryConnectedComponent getConnectedComponent(Map<TermPairEdgepairsMap<TermLoopallLoopsList<FunctionnonDLAtoms,
																Term seed) {
		Set<TermccTerms = new HashSet<Term>((allLoops.size() * 2) / 3);
		List<EdgeccEdges = new ArrayList<Edge>(pairs.size());
		List<FunctionccNonDLAtoms = new LinkedList<Function>();
		List<LoopccLoops = new ArrayList<Loop>(allLoops.size());
		ccTerms.add(seed);
		Loop seedLoop = allLoops.get(seed);
		if (seedLoop != null) {
			ccLoops.add(seedLoop);
			allLoops.remove(seed);
		}
		// expand the current CC by adding all edges that are have at least one of the NewLiterals in them
		boolean expanded = true;
		while (expanded) {
			expanded = false;
			//i = pairs.entrySet().iterator();
			while (i.hasNext()) {
				Edge edge = i.next().getValue();
				Term t0 = edge.getTerm0();
				Term t1 = edge.getTerm1();
				if (ccTerms.contains(t0)) {
					if (ccTerms.add(t1))  { // the other term is already there
						ccLoops.add(edge.getLoop1());
						allLoops.remove(t1); // remove the loops that are covered by the edges in CC
					}
				}
				else if (ccTerms.contains(t1)) {
					if (ccTerms.add(t0))  { // the other term is already there
						ccLoops.add(edge.getLoop0()); 
						allLoops.remove(t0); // remove the loops that are covered by the edges in CC
					}
				}
				else
					continue;
				ccEdges.add(edge);
				expanded = true;
				i.remove();
			}
			// non-DL atoms
			Iterator<Functionni = nonDLAtoms.iterator();
			while (ni.hasNext()) {
				Function atom = ni.next();
				boolean intersects = false;
				Set<VariableatomVars = atom.getReferencedVariables();
				for (Variable t : atomVars
					if (ccTerms.contains(t)) {
						intersects = true;
						break;
					}
				if (intersects) {
					ccNonDLAtoms.add(atom);
					ccTerms.addAll(atomVars);
					for (Variable v : atomVars) {
						allLoops.remove(v);
					}
					expanded = true;
					ni.remove();
				}
			}
		}
		return new QueryConnectedComponent(ccEdgesccNonDLAtomsccLoops); 
	}

getConnectedComponents creates a list of connected components of a given CQ

Parameters:
cqie: CQ to be split into connected components
Returns:
list of connected components
		Set<TermheadTerms = new HashSet<Term>(cqie.getHead().getTerms());
		// collect all edges and loops 
		//      an edge is a binary predicate P(t, t') with t \ne t'
		// 		a loop is either a unary predicate A(t) or a binary predicate P(t,t)
		//      a nonDL atom is an atom with a non-data predicate 
		Map<TermPairEdgepairs = new HashMap<TermPairEdge>();
		Map<TermLoopallLoops = new HashMap<TermLoop>();
		List<FunctionnonDLAtoms = new LinkedList<Function>();
		for (Function acqie.getBody()) {
			if (p.isDataPredicate() && !p.isTriplePredicate()) { // if DL predicates 
			//if (p.isClass() || p.isObjectProperty() || p.isDataProperty()) { // if DL predicate (throws NullPointerException)
				Term t0 = a.getTerm(0);				
				if (a.getArity() == 2 && !t0.equals(a.getTerm(1))) {
					// proper DL edge between two distinct terms
					Term t1 = a.getTerm(1);
					TermPair pair = new TermPair(t0t1);
					Edge edge =  pairs.get(pair); 
					if (edge == null) {
						Loop l0 = getLoop(t0allLoopsheadTerms);
						Loop l1 = getLoop(t1allLoopsheadTerms);
						edge = new Edge(l0l1);
						pairs.put(pairedge);
					}
					edge.bAtoms.add(a);			
				}
				else {
					Loop l0 = getLoop(t0allLoopsheadTerms);
					l0.atoms.add(a);
				}
			}
			else { // non-DL precicate
				//log.debug("NON-DL ATOM {}",  a);
				nonDLAtoms.add(a);
			}
		}	
		// form the list of connected components from the list of edges
		while (!pairs.isEmpty()) {
			Edge edge = pairs.entrySet().iterator().next().getValue();			
			ccs.add(getConnectedComponent(pairsallLoopsnonDLAtomsedge.getTerm0()));			
		}
		while (!nonDLAtoms.isEmpty()) {
			//log.debug("NON-DL ATOMS ARE NOT EMPTY: {}", nonDLAtoms);
			Function f = nonDLAtoms.iterator().next(); 
			Variable v = vars.iterator().next();
			ccs.add(getConnectedComponent(pairsallLoopsnonDLAtomsv));			
		}
		// create degenerate connected components for all remaining loops (which are disconnected from anything else)
		//for (Entry<NewLiteral, Loop> loop : allLoops.entrySet()) {
		while (!allLoops.isEmpty()) {
			Term seed = allLoops.keySet().iterator().next();
			ccs.add(getConnectedComponent(pairsallLoopsnonDLAtomsseed));			
			//ccs.add(new QueryConnectedComponent(Collections.EMPTY_LIST, loop.getValue(), Collections.EMPTY_LIST, Collections.singletonList(loop.getValue())));
		}
		return ccs;
	}
	public Loop getLoop() {
		return ;
	}

boolean isDenenerate()

Returns:
true if the component is degenerate (has no proper edges with two distinct terms)
	public boolean isDegenerate() {
		return .isEmpty(); // && nonDLAtoms.isEmpty();
	}

boolean hasNoFreeTerms()

Returns:
true if all terms of the connected component are existentially quantified variables
	public boolean hasNoFreeTerms() {
		return ;
	}

List<Edge> getEdges()

Returns:
the list of edges in the connected component
	public List<EdgegetEdges() {
		return ;
	}

List<Term> getVariables()

Returns:
the list of variables in the connected components
	public List<TermgetVariables() {
		return ;		
	}

Set<Variable> getQuantifiedVariables()

Returns:
the collection of existentially quantified variables
	}

List<Term> getFreeVariables()

Returns:
the list of free variables in the connected component
	public List<TermgetFreeVariables() {
	}
		return ;
	}

Loop: class representing loops of connected components a loop is characterized by a Term and a set of atoms involving only that Term

Author(s):
Roman Kontchakov
	static class Loop {
		private final Term term;
		private final boolean isExistentialVariable;
		public Loop(Term termboolean isExistentialVariable) {
			this. = term;
			this. = isExistentialVariable;
			this. = new ArrayList<Function>(10);
		}
		public Term getTerm() {
			return ;
		}
			return ;
		}
		public boolean isExistentialVariable() {
		}
		public String toString() {
			return "loop: {" +  + "}" + ;
		}
		public boolean equals(Object o) {
			if (o instanceof Loop
				return .equals(((Loop)o).);
			return false;
		}
		public int hashCode() {
			return .hashCode();
		}
	}

Edge: class representing edges of connected components an edge is characterized by a pair of Terms and a set of atoms involving only those Terms

Author(s):
Roman Kontchakov
	static class Edge {
		private final Loop l0l1;
		public Edge(Loop l0Loop l1) {
			this. = new ArrayList<Function>(10);
			this. = l0;
			this. = l1;
		}
		public Loop getLoop0() {
			return ;
		}
		public Loop getLoop1() {
			return ;
		}
		public Term getTerm0() {
			return .;
		}
		public Term getTerm1() {
			return .;
		}
			return ;
		}
		public List<FunctiongetAtoms() {
			List<FunctionallAtoms = new ArrayList<Function>(.size() + ..size() + ..size());
			allAtoms.addAll();
			allAtoms.addAll(.);
			allAtoms.addAll(.);
			return allAtoms;
		}
		public String toString() {
			return "edge: {" + . + ", " + . + "}" +  + . + .;
		}
	}

TermPair: a simple abstraction of *unordered* pair of Terms (i.e., {t1, t2} and {t2, t1} are equal)

Author(s):
Roman Kontchakov
	private static class TermPair {
		private final Term t0t1;
		private final int hashCode;
		public TermPair(Term t0Term t1) {
			this. = t0;
			this. = t1;
			this. = t0.hashCode() ^ t1.hashCode();
		}
		public boolean equals(Object o) {
			if (o instanceof TermPair) {
				TermPair other = (TermPairo;
				if (this..equals(other.t0) && this..equals(other.t1))
					return true;
				if (this..equals(other.t1) && this..equals(other.t0))
					return true;
			}
			return false;
		}
		public String toString() {
			return "term pair: {" +  + ", " +  + "}";
		}
		public int hashCode() {
			return ;
		}
	}	
New to GrepCode? Check out our FAQ X