public GensonBuilder withDeserializers(Deserializer<?>... deserializer) { for (Deserializer<?> d : deserializer) { Type typeOfConverter = TypeUtil.typeOf(0, TypeUtil.lookupGenericType(Deserializer.class, d.getClass())); typeOfConverter = TypeUtil.expandType(typeOfConverter, d.getClass()); registerDeserializer(d, typeOfConverter); } return this; }
public GensonBuilder withSerializers(Serializer<?>... serializer) { for (Serializer<?> s : serializer) { Type typeOfConverter = TypeUtil.typeOf(0, TypeUtil.lookupGenericType(Serializer.class, s.getClass())); typeOfConverter = TypeUtil.expandType(typeOfConverter, s.getClass()); registerSerializer(s, typeOfConverter); } return this; }
/** * Registers converters mapping them to their corresponding parameterized type. * * @param converter * @return a reference to this builder. */ public GensonBuilder withConverters(Converter<?>... converter) { for (Converter<?> c : converter) { Type typeOfConverter = TypeUtil.typeOf(0, TypeUtil.lookupGenericType(Converter.class, c.getClass())); typeOfConverter = TypeUtil.expandType(typeOfConverter, c.getClass()); registerConverter(c, typeOfConverter); } return this; }
private void addDefaultSerializers(List<? extends Serializer<?>> serializers) { if (serializers != null) { for (Serializer<?> serializer : serializers) { Type typeOfConverter = TypeUtil.typeOf(0, TypeUtil.lookupGenericType(Serializer.class, serializer.getClass())); typeOfConverter = TypeUtil.expandType(typeOfConverter, serializer.getClass()); if (!serializersMap.containsKey(typeOfConverter)) serializersMap.put(typeOfConverter, serializer); } } }
private void addDefaultDeserializers(List<? extends Deserializer<?>> deserializers) { if (deserializers != null) { for (Deserializer<?> deserializer : deserializers) { Type typeOfConverter = TypeUtil.typeOf( 0, TypeUtil.lookupGenericType(Deserializer.class, deserializer.getClass())); typeOfConverter = TypeUtil.expandType(typeOfConverter, deserializer.getClass()); if (!deserializersMap.containsKey(typeOfConverter)) deserializersMap.put(typeOfConverter, deserializer); } } }
/** * Returns a shallow copy of this graph instance. Neither edges nor vertices are cloned. * * @return a shallow copy of this set. * @throws RuntimeException * @see java.lang.Object#clone() */ public Object clone() { try { TypeUtil<AbstractBaseGraph<V, E>> typeDecl = null; AbstractBaseGraph<V, E> newGraph = TypeUtil.uncheckedCast(super.clone(), typeDecl); newGraph.edgeMap = new LinkedHashMap<E, IntrusiveEdge>(); newGraph.edgeFactory = this.edgeFactory; newGraph.unmodifiableEdgeSet = null; newGraph.unmodifiableVertexSet = null; // NOTE: it's important for this to happen in an object // method so that the new inner class instance gets associated with // the right outer class instance newGraph.specifics = newGraph.createSpecifics(); Graphs.addGraph(newGraph, this); return newGraph; } catch (CloneNotSupportedException e) { e.printStackTrace(); throw new RuntimeException(); } }
@Override public FieldValue evaluate(List<FieldValue> values) { StorelessUnivariateStatistic statistic = createStatistic(); DataType dataType = null; for (FieldValue value : values) { // "Missing values in the input to an aggregate function are simply ignored" if (value == null) { continue; } statistic.increment((value.asNumber()).doubleValue()); if (dataType != null) { dataType = TypeUtil.getResultDataType(dataType, value.getDataType()); } else { dataType = value.getDataType(); } } if (statistic.getN() == 0) { throw new MissingResultException(null); } Object result = cast(getResultType(dataType), statistic.getResult()); return FieldValueUtil.create(result); }
@Override public FieldValue evaluate(List<FieldValue> values) { if (values.size() != 2) { throw new EvaluationException(); } FieldValue left = values.get(0); FieldValue right = values.get(1); // "If one of the input fields of a simple arithmetic function is a missing value, the result // evaluates to missing value" if (left == null || right == null) { return null; } DataType dataType = TypeUtil.getResultDataType(left.getDataType(), right.getDataType()); Number result; try { result = evaluate(left.asNumber(), right.asNumber()); } catch (ArithmeticException ae) { throw new InvalidResultException(null); } return FieldValueUtil.create(cast(dataType, result)); }
/** @see Graph#getEdgeTarget(Object) */ public V getEdgeTarget(E e) { return TypeUtil.uncheckedCast(getIntrusiveEdge(e).target, vertexTypeDecl); }
/** @see Graph#getEdgeSource(Object) */ public V getEdgeSource(E e) { return TypeUtil.uncheckedCast(getIntrusiveEdge(e).source, vertexTypeDecl); }