@Override public Converter<Interval> create(Type type, Genson genson) { return new IntervalConverter(genson.<DateTime>provideConverter(DateTime.class)); } }
@Override public Converter<Interval> create(Type type, Genson genson) { return new IntervalConverter(genson.<DateTime>provideConverter(DateTime.class)); } }
@Override public Converter<Optional<Object>> create(Type type, Genson genson) { Type typeOfValue = TypeUtil.typeOf(0, type); return new OptionalConverter<Object>(genson.provideConverter(typeOfValue)); } }
@Override public Converter<Optional<Object>> create(Type type, Genson genson) { Type typeOfValue = TypeUtil.typeOf(0, type); return new OptionalConverter<Object>(genson.provideConverter(typeOfValue)); } }
Converter<List<Note>> noteListConverter = genson.provideConverter(new GenericType<List<Note>>() {}.getType()); Converter<Note> noteConverter = genson.provideConverter(Note.class); return new NotesDeserializer(noteListConverter, noteConverter);
/** * Serializes this object and writes its representation to writer. As you are providing the * writer instance you also must ensure to call close on it when you are done. */ public void serialize(Object object, Type type, ObjectWriter writer, Context ctx) { Serializer<Object> ser = provideConverter(type); try { ser.serialize(object, writer, ctx); writer.flush(); } catch (Exception e) { throw new JsonBindingException("Failed to serialize object of type " + type, e); } }
/** * Serializes this object and writes its representation to writer. As you are providing the * writer instance you also must ensure to call close on it when you are done. */ public void serialize(Object object, Type type, ObjectWriter writer, Context ctx) { Serializer<Object> ser = provideConverter(type); try { ser.serialize(object, writer, ctx); writer.flush(); } catch (Exception e) { throw new JsonBindingException("Failed to serialize object of type " + type, e); } }
@SuppressWarnings({"rawtypes", "unchecked"}) public Converter<Object> create(Type forType, Genson genson) { if (forType instanceof GenericArrayType || (forType instanceof Class<?> && ((Class<?>) forType).isArray())) { if (byte.class.equals(getCollectionType(forType))) { return (Converter) ByteArrayConverter.instance; } else { Converter<?> elementConverter = genson.provideConverter(TypeUtil .getCollectionType(forType)); return new ArrayConverter(TypeUtil.getRawClass(TypeUtil .getCollectionType(forType)), elementConverter); } } return null; } }
@SuppressWarnings({"rawtypes", "unchecked"}) public Converter<Object> create(Type forType, Genson genson) { if (forType instanceof GenericArrayType || (forType instanceof Class<?> && ((Class<?>) forType).isArray())) { if (byte.class.equals(getCollectionType(forType))) { return (Converter) ByteArrayConverter.instance; } else { Converter<?> elementConverter = genson.provideConverter(TypeUtil .getCollectionType(forType)); return new ArrayConverter(TypeUtil.getRawClass(TypeUtil .getCollectionType(forType)), elementConverter); } } return null; } }
public <T> T deserialize(GenericType<T> type, ObjectReader reader, Context ctx) { Deserializer<T> deser = provideConverter(type.getType()); try { return deser.deserialize(reader, ctx); } catch (Exception e) { throw new JsonBindingException("Could not deserialize to type " + type.getRawClass(), e); } }
public <T> T deserialize(GenericType<T> type, ObjectReader reader, Context ctx) { Deserializer<T> deser = provideConverter(type.getType()); try { return deser.deserialize(reader, ctx); } catch (Exception e) { throw new JsonBindingException("Could not deserialize to type " + type.getRawClass(), e); } }
@SuppressWarnings({"rawtypes", "unchecked"}) public Converter<? extends Map<?, ?>> create(Type type, Genson genson) { // ok this is a fix but not the cleanest one... we make sure it is a parameterized type // otherwise we search for map impl in its hierarchy Type expandedType = type; if (getRawClass(type).getTypeParameters().length == 0) { expandedType = expandType(lookupGenericType(Map.class, getRawClass(type)), type); } Type keyType = typeOf(0, expandedType); Type valueType = typeOf(1, expandedType); Class<?> keyRawClass = getRawClass(keyType); KeyAdapter<?> keyAdapter = keyAdapter(keyRawClass); if (keyAdapter != null) return createConverter(getRawClass(type), keyAdapter, genson.provideConverter(valueType)); else return new ComplexMapConverter(genson.provideConverter(keyType), genson.provideConverter(valueType)); }
@SuppressWarnings({"rawtypes", "unchecked"}) public Converter<? extends Map<?, ?>> create(Type type, Genson genson) { // ok this is a fix but not the cleanest one... we make sure it is a parameterized type // otherwise we search for map impl in its hierarchy Type expandedType = type; if (getRawClass(type).getTypeParameters().length == 0) { expandedType = expandType(lookupGenericType(Map.class, getRawClass(type)), type); } Type keyType = typeOf(0, expandedType); Type valueType = typeOf(1, expandedType); Class<?> keyRawClass = getRawClass(keyType); KeyAdapter<?> keyAdapter = keyAdapter(keyRawClass); if (keyAdapter != null) return createConverter(getRawClass(type), keyAdapter, genson.provideConverter(valueType)); else return new ComplexMapConverter(genson.provideConverter(keyType), genson.provideConverter(valueType)); }
@SuppressWarnings({"rawtypes", "unchecked"}) public Converter<Collection<?>> create(Type forType, Genson genson) { Converter<?> elementConverter = genson.provideConverter(TypeUtil.getCollectionType(forType)); Class<?> parameterRawClass = TypeUtil.getRawClass(TypeUtil.getCollectionType(forType)); Class<?> rawClass = getRawClass(forType); if (EnumSet.class.isAssignableFrom(rawClass) && parameterRawClass.isEnum()) return new EnumSetConverter(parameterRawClass, elementConverter); if (LinkedHashSet.class.isAssignableFrom(rawClass)) return new LinkedHashSetConverter(parameterRawClass, elementConverter); if (TreeSet.class.isAssignableFrom(rawClass)) return new TreeSetConverter(parameterRawClass, elementConverter); if (Set.class.isAssignableFrom(rawClass)) return new SetConverter(parameterRawClass, elementConverter); if (LinkedList.class.isAssignableFrom(rawClass)) return new LinkedListConverter(parameterRawClass, elementConverter); if (ArrayDeque.class.isAssignableFrom(rawClass)) return new ArrayDequeConverter(parameterRawClass, elementConverter); if (PriorityQueue.class.isAssignableFrom(rawClass)) return new PriorityQueueConverter(parameterRawClass, elementConverter); return new CollectionConverter(parameterRawClass, elementConverter); } }
@SuppressWarnings({"rawtypes", "unchecked"}) public Converter<Collection<?>> create(Type forType, Genson genson) { Converter<?> elementConverter = genson.provideConverter(TypeUtil.getCollectionType(forType)); Class<?> parameterRawClass = TypeUtil.getRawClass(TypeUtil.getCollectionType(forType)); Class<?> rawClass = getRawClass(forType); if (EnumSet.class.isAssignableFrom(rawClass) && parameterRawClass.isEnum()) return new EnumSetConverter(parameterRawClass, elementConverter); if (LinkedHashSet.class.isAssignableFrom(rawClass)) return new LinkedHashSetConverter(parameterRawClass, elementConverter); if (TreeSet.class.isAssignableFrom(rawClass)) return new TreeSetConverter(parameterRawClass, elementConverter); if (Set.class.isAssignableFrom(rawClass)) return new SetConverter(parameterRawClass, elementConverter); if (LinkedList.class.isAssignableFrom(rawClass)) return new LinkedListConverter(parameterRawClass, elementConverter); if (ArrayDeque.class.isAssignableFrom(rawClass)) return new ArrayDequeConverter(parameterRawClass, elementConverter); if (PriorityQueue.class.isAssignableFrom(rawClass)) return new PriorityQueueConverter(parameterRawClass, elementConverter); return new CollectionConverter(parameterRawClass, elementConverter); } }
private Converter<Object> provide(BeanProperty property, Genson genson) { // contextual converters must not be retrieved from cache nor stored in cache, by first // trying to create it and reusing it during the // call to genson.provideConverter we avoid retrieving it from cache, and by setting // DO_NOT_CACHE_CONVERTER to true we tell genson not to store // this converter in cache @SuppressWarnings("unchecked") Converter<Object> converter = (Converter<Object>) contextualConverterFactory.provide( property, genson); if (converter != null) { ThreadLocalHolder.store(DO_NOT_CACHE_CONVERTER_KEY, true); ThreadLocalHolder.store(CONTEXT_KEY, converter); } try { return genson.provideConverter(property.type); } finally { if (converter != null) { ThreadLocalHolder.remove(DO_NOT_CACHE_CONVERTER_KEY, Boolean.class); ThreadLocalHolder.remove(CONTEXT_KEY, Converter.class); } } }
private Converter<Object> provide(BeanProperty property, Genson genson) { // contextual converters must not be retrieved from cache nor stored in cache, by first // trying to create it and reusing it during the // call to genson.provideConverter we avoid retrieving it from cache, and by setting // DO_NOT_CACHE_CONVERTER to true we tell genson not to store // this converter in cache @SuppressWarnings("unchecked") Converter<Object> converter = (Converter<Object>) contextualConverterFactory.provide( property, genson); if (converter != null) { ThreadLocalHolder.store(DO_NOT_CACHE_CONVERTER_KEY, true); ThreadLocalHolder.store(CONTEXT_KEY, converter); } try { return genson.provideConverter(property.type); } finally { if (converter != null) { ThreadLocalHolder.remove(DO_NOT_CACHE_CONVERTER_KEY, Boolean.class); ThreadLocalHolder.remove(CONTEXT_KEY, Converter.class); } } }
public T deserialize(ObjectReader reader, Context ctx) throws Exception { if (ValueType.OBJECT.equals(reader.getValueType())) { String className = reader.nextObjectMetadata().metadata("class"); if (className != null) { try { Class<?> classFromMetadata = ctx.genson.classFor(className); if (!classFromMetadata.equals(tClass)) { Converter<T> deser = ctx.genson.provideConverter(classFromMetadata); return deser.deserialize(reader, ctx); } } catch (ClassNotFoundException e) { throw new JsonBindingException( "Could not use @class metadata, no such class: " + className); } } } return wrapped.deserialize(reader, ctx); } }
public T deserialize(ObjectReader reader, Context ctx) throws Exception { if (readClassMetadata && ValueType.OBJECT.equals(reader.getValueType())) { String className = reader.nextObjectMetadata().metadata("class"); if (className != null) { try { Class<?> classFromMetadata = ctx.genson.classFor(className); if (!classFromMetadata.equals(tClass)) { Converter<T> deser = ctx.genson.provideConverter(classFromMetadata); return deser.deserialize(reader, ctx); } } catch (ClassNotFoundException e) { throw new JsonBindingException( "Could not use @class metadata, no such class: " + className); } } } return wrapped.deserialize(reader, ctx); } }
@Override public Converter<? extends Map<?, ?>> create(Type type, Genson genson) { Type expandedType = type; if (getRawClass(type).getTypeParameters().length == 0) { expandedType = expandType(lookupGenericType(Map.class, getRawClass(type)), type); } Type keyType = typeOf(0, expandedType); Type valueType = typeOf(1, expandedType); Class<?> keyRawClass = getRawClass(keyType); DefaultConverters.KeyAdapter<?> keyAdapter; if (keyRawClass.equals(IdRef.class)) { keyAdapter = this.idRefAdapter; } else { keyAdapter = DefaultConverters.MapConverterFactory.keyAdapter(keyRawClass); } Converter<Object> valueConverter; if (valueIsLazyJsonIfList(valueType)) { valueConverter = LazyJsonConverters.get(null, valueType); } else { valueConverter = genson.provideConverter(valueType); } if (keyAdapter != null) { return createConverter(getRawClass(type), keyAdapter, valueConverter); } return null; }