/** * Returns the prior probability for <code>v</code>. * @param v the vertex whose prior probability is being queried * @return the prior probability for <code>v</code> */ protected S getVertexPrior(V v) { return vertex_priors.transform(v); }
/** * Returns the prior probability for <code>v</code>. * * @param v * the vertex whose prior probability is being queried * @return the prior probability for <code>v</code> */ protected S getVertexPrior(V v) { return vertex_priors.transform(v); }
/** * Transforms the input to result via each decorated transformer * * @param object * the input object passed to the first transformer * @return the transformed result */ @Override public O transform(I object) { Object intermediate = object; for (int i = 0; i < iTransformers.length; i++) { intermediate = iTransformers[i].transform(intermediate); } return (O) intermediate; }
private double calculatePathCost(final List<E> path){ double result = 0; for(E edge : path) { result += defaultEdgeWeight.transform(edge).doubleValue(); } return result; } }
@Override public V get(Object key) { V result; try { @SuppressWarnings("unchecked") K k = (K)key; K normKey = keyNormalizer.transform(k); result = map.get(normKey); } catch(ClassCastException e) { result = null; } return result; }
@Override public boolean containsKey(Object key) { boolean result; try { @SuppressWarnings("unchecked") K k = (K)key; K normKey = keyNormalizer.transform(k); result = map.containsKey(normKey); } catch(ClassCastException e) { result = false; } return result; }
@Override public Integer transform(ONDEXConcept arg0) { if (entitiesSizes.containsKey(arg0)) return entitiesSizes.get(arg0); return oldSizes.transform(arg0); } };
@Override public List<AttributeExtractor> transform(Integer arg0) { List<AttributeExtractor> existing = null; for (Transformer<Integer, List<AttributeExtractor>> transformer : transformers) { List<AttributeExtractor> result = transformer.transform(arg0); if (result == null) continue; if (existing == null) { existing = result; } else { existing.addAll(result); } } return existing; }
private Rectangle getBound(final Node n, final Transformer<Node, Shape> vst) { if (vst == null) { return new Rectangle(0, 0); } return vst.transform(n).getBounds(); }
@Override public Integer transform(ONDEXRelation arg0) { if (entitiesSizes.containsKey(arg0)) return entitiesSizes.get(arg0); if (oldSizes != null) return oldSizes.transform(arg0); return Config.defaultEdgeSize; } };
@Override public Integer transform(ONDEXRelation e) { if (!cache.containsKey(e)) return UNITLENGTHFUNCTION.transform(e); return cache.get(e); } }
@Override @SuppressWarnings("unchecked") public V get(Object key) { // create value for key if key is not currently in the map if (map.containsKey(key) == false) { V value = this.transformer.transform((K) key); map.put((K) key, value); return value; } return map.get(key); }
@Override public Point2D transform(V input) { Point2D p = new Point2D.Double(); p.setLocation(vertexPositionTransformer.transform(input)); p.setLocation(p.getX(), -p.getY()); return p; } };
/** * @see Transformer#transform(Object) */ public Number transform(VEPair<V,E> arg0) { return delegate.transform(arg0.getE()); }
public String transform(String s) { final Transformer<String, String> transformer = createTransformer(); if (transformer == null) return null; return transformer.transform(s); } };
public String transform(String s) { final Transformer<String, String> transformer = createTransformer(); if (transformer == null) return ""; return transformer.transform(s); } };
/** * Gets the edge weight for <code>e</code> in the context of its (incident) vertex <code>v</code>. * @param v the vertex incident to e as a context in which the edge weight is to be calculated * @param e the edge whose weight is to be returned * @return the edge weight for <code>e</code> in the context of its (incident) vertex <code>v</code> */ protected Number getEdgeWeight(V v, E e) { return edge_weights.transform(new VEPair<V,E>(v,e)); }
private <G> Map<String, String> getParams(String v, Map<String, GraphMLMetadata<String>> vertexMetadata) { HashMap<String, String> params = new HashMap<String, String>(); for (String key : vertexMetadata.keySet()){ String value = vertexMetadata.get(key).transformer.transform(v); if (value == null) continue; if (!params.containsKey(key)){ params.put(key,value); } else{ value = value.concat(", ").concat(params.get(key)); params.put(key,value); } } return params; }
@Override public V put(K key, V value) { K normKey = keyNormalizer.transform(key); //if(origToNorm.inverseBidiMap().get(normKey) origToNorm.put(key, normKey); map.put(normKey, value); return value; }