/** * Create new deserializer based on default {@link Boss} - optimized {@link BiMapper}. * @return */ public static BiDeserializer newDeserializer() { return new BiDeserializer(getInstance()); }
/** * Register serializabble class in the default Boss mapper only. See {@link BiMapper#registerClass(Class)} for more * information. * * @param klass */ public static void registerClass(Class<? extends BiSerializable> klass) { getInstance().registerClass(klass); }
/** * {@link #deserialize(Map, BiDeserializer)} using default {@link BiDeserializer}. * * @param map to deserialize * @param <T> * * @return deserialized object of the map with deserialized values. */ public <T> T deserialize(Map map) { return deserialize(map, new BiDeserializer(this)); }
public static void deserializeInPlace(Map map) { new BiDeserializer(getInstance()).deserializeInPlace(map); }
public static void recalculateMapper() { BiMapper full = DefaultBiMapper.getInstance(); if (mapper == null || lastRevision < full.getRevision()) { BiMapper m = new BiMapper(full); lastRevision = full.getRevision(); m.unregister(ZonedDateTime.class); m.unregister((new byte[0]).getClass()); m.unregister(Bytes.class); mapper = m; } }
/** * Create new serializer based on default {@link Boss} - optimized {@link BiMapper}. * @return */ public static BiSerializer newSerializer() { return new BiSerializer(getInstance()); } }
public <T> T deserializeObject(Object x) { return x == null ? null : deserializeObject(x, new BiDeserializer(this)); }
default Binder toBinder() { return DefaultBiMapper.serialize(this); } }
/** * Same as {@link #serialize(Object, BiSerializer)} with default {@link BiSerializer}. */ public @NonNull <T> T serialize(Object x) { return serialize(x, new BiSerializer(this)); }
/** * Register serialization adapter in the default Boss mapper only. See {@link BiMapper#registerAdapter(Class, * BiAdapter)} for more information. * * @param klass * @param adapter */ public static void registerAdapter(Class<?> klass, BiAdapter adapter) { getInstance().registerAdapter(klass, adapter); }
/** * Construct deserializer with {@link DefaultBiMapper} */ public BiDeserializer() { mapper = DefaultBiMapper.getInstance(); }
/** * Add a class to serializable with this mapper. Remeber to have nonparametric constructor (possibly private) * so deserializer could create its instances. * * @param klass to register */ public void registerClass(Class<? extends BiSerializable> klass) { registerAdapter(klass, new BiSerializableAdapter(klass)); }
/** * Construct new serializer to use this mapper */ public BiSerializer newSerializer() { return new BiSerializer(this); }
/** * Construct new deserializer to use this mapper */ public BiDeserializer newDeserializer() { return new BiDeserializer(this); } }
/** * Serialize any object. See {@link BiMapper#deserializeObject(Object, BiDeserializer)} for more information. * * @param obj * @param <T> * * @return */ public <T> T serialize(Object obj) { return mapper.serialize(obj, this); }
/** * Modify a map by deserializing it's values in place. Saves memory. * * @param map */ public void deserializeInPlace(Map map) { mapper.deserializeInPlace(map, this); }
/** * Creates writer to write to the output stream. Upon creation writer is alwais in tree mode. * * @param outputStream See {@link #setStreamMode()} */ public Writer(OutputStream outputStream) { this(outputStream, BossBiMapper.newSerializer()); }
/** * Register a class with explicit de/serialization methods. See {@link BiSerializable}. * * @param klass class to register. */ public static void registerClass(Class<? extends BiSerializable> klass) { defaultInstance.registerClass(klass); }
/** * Create serialized to work with default mapper, {@link DefaultBiMapper#getInstance()}. */ public BiSerializer() { this.mapper = DefaultBiMapper.getInstance(); }