Public

getFirst

concat

getLast

size

toString

List

Making http post requests using okhttp

This Graphics2D class extends the Graphics class to provide more sophisticated
control overgraphics 

java.awt.Graphics2D

An immutable arbitrary-precision signed decimal.A value is represented by an
arbitrary-precision "un

java.math.BigDecimal

A linear collection that supports element insertion and removal at both ends.
The name deque is shor

java.util.Deque

javax.imageio.ImageIO

A filter is an object that performs filtering tasks on either the request to a
resource (a servlet o

javax.servlet.Filter

javax.swing.JFrame

startActivity

getSupportFragmentManager

setRequestProperty

/**
 * The result is a list of candidate matches ordered by sepecificity.
 * The each item comprises the attributes:
 * - The entry-key
 * - The Op-Map
 * - The Var-Map
 * - The projected op
 * - (Optionally internal properties: OpIndex and FeatureSet)
 *
 * So we have two options how to structure the result:
 * Nested:
 * From the op-mapping, navigate to the var-mapping and from there to the entry-data
 * Map<Op, Op> -> Map<Var, Var> -> (Key, ProjectedOp)
 *
 * Flat:
 * (key, opmap, varmap, projected op, [op index, feature set])
 *
 * Indirect:
 * The result is:
 * OpVarMap and patternId
 *
 *
 * The advantage of the flat structure is obviously the simplicity
 * The disadvantage of the flat structure is, that it may be suboptimal for efficient processing
 *
 *
 *
 *
 * @param pop
 * @return
 */

// public Collection<KeyedOpVarMap> lookup(ProjectedOp pop) {

//    	Op patternOp = pop.getResidualOp();

// 	Collection<KeyedOpVarMap> candidates = lookup(patternOp);

//    	// For each pattern id, check the projection

// 	for(LookupResult cand : candidates) {

//    		int patternId = cand.getEntry().id;

//			Map<K, ProjectedOp> keyToPop = patternIdToKeyToPop.getOrDefault(patternId, Collections.emptyMap());

//    		// TODO What if there are multiple opVarMaps?

//			// Note: For a given variable mapping, there can be multiple projections, such as{ (?s), (?s ?p), (?p) }

//			// So we first determine all compatible ones, and then sort them by specificity.

//			// We can then select one of the most specific ones.

//			// The lookup result is then: OpVarMap, with for every var map the list of projections

//			// ISSUE Using var maps as keys in a map feels wrong - but maybe in that case it is justified - as the set of candidate projections

//			// really depend on the variable mapping

//    		OpVarMap opVarMap = cand.getOpVarMap();

//    		// For each var map get the set of compatible projections

// 		Iterable<Map<Var,Var>> filteredVarMaps = () -> StreamUtils.stream(opVarMap.getVarMaps())

//    			.filter(varMap -> SparqlViewMatcherProjectionUtils.validateProjection(e.getValue().getProjection(), pop.getProjection(), varMap))

//    		opVarMap = new OpVarMap(opVarMap.getOpMap(), filteredVarMaps);

//	 			// TODO Maybe make this lazy: Iterable<> foo = () -> keyToPop.stream()....interator()

//		 		List<Map<Var, Var>> varMaps = keyToPop.entrySet().stream()

//		    			.filter(e -> SparqlViewMatcherProjectionUtils.validateProjection(e.getValue().getProjection(), pop.getProjection(), varMap))

//		    			.collect(Collectors.toList());

//		    		OpVarMap r = new OpVarMap(opVarMap.getOpMap(), varMaps);

//    			// Remove all candidates for which no projection was compatible

//Op normalizedItem = opNormalizer.rewrite(item);

//        itemFeatureExtractor.apply(item).forEach(featureSet -> {

//            //featuresToIndexes.getIfSubsetOf(featureSet).stream()

//            featuresToIndexes.get(featureSet).stream()

//                //.map(e -> e.getValue())

//                .forEach(x -> tmpCands.add(x));

// TODO if there is a projection on item, the lookup fails, because

// in the index we cut the projection away

//featuresToIndexes.getIfSubsetOf(featureSet).stream()

// Order candidates by their node count - largest node counts (number of operators in the algebra tree) first

//List<KeyedOpVarMap> result = new ArrayList<>();

//OpIndex cacheIndex = cacheEntry.queryIndex;

// TODO: Require a complete match of the tree - i.e. cache and query trees must have same number of nodes / same depth / some other criteria that can be checked quickly

// In fact, we could use these features as an additional index

// We need to update the queryIndex (remove sub-trees that matched)

//KeyedOpVarMap lr = new KeyedOpVarMap(cacheEntry, opVarMap);

How to use toStringmethodin org.apache.jena.ext.com.google.common.collect.Iterables

Best Java code snippets using org.apache.jena.ext.com.google.common.collect.Iterables.toString (Showing top 2 results out of 315)

How to use
toString
method
in
org.apache.jena.ext.com.google.common.collect.Iterables