/** * Deserialize some object if need. E.g. if the object is a simple type supported by most notations, e.g. numbers, * strings, it is left unchanged, but if it is a collection or a Map it will be processed to deserialize its * content. See {@link BiMapper#deserializeObject(Object)} for details * * @param object to deserialize * @param <T> * @param <U> * * @return restored object */ public <T, U> T deserialize(U object) { return (T) mapper.deserializeObject(object, this); }
public static <T> void registerAdapter(Class<T> klass, BiAdapter adapter) { defaultInstance.registerAdapter(klass, adapter); }
/** * 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); }
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; } }
biMapper.unregister(KeyAddress.class); biMapper.registerAdapter(KeyAddress.class, customKeyAddressBiAdapter); biMapper.unregister(Reference.class); biMapper.registerAdapter(Reference.class, customReferenceBiAdapter); Binder binder = contract.serialize(biMapper.newSerializer()); biMapper.unregister(KeyAddress.class); biMapper.registerAdapter(KeyAddress.class, KeyAddress.getBiAdapter()); biMapper.unregister(Reference.class); DefaultBiMapper.registerClass(Reference.class);
/** * Deserialize any object, if possible. * <p> * <ul> <li>if the object is a simple type, e.g. number, string, boolean, it will be simply retured.</li> <li>if the * object is a collection, every item of it will be deserialized the sam way and the result will be returned as a * List with random access (like ArrayList)</li> <li>if the object is a map, it will be processed as with {@link * #deserialize(Map, BiDeserializer)}</li> </ul> * * @param obj to deserealize * @param deserializer to * @param <T> * * @return */ public <T> T deserializeObject(Object obj, BiDeserializer deserializer) { if (obj instanceof String || obj instanceof Number || obj instanceof Boolean || obj instanceof ZonedDateTime || obj instanceof Bytes || obj == null) return (T) obj; if (obj instanceof Map) return deserialize((Map) obj, deserializer); if (obj instanceof Collection) { return (T) ((Collection) obj).stream() .map(x -> deserializeObject(x)) .collect(Collectors.toList()); } throw new IllegalArgumentException("don't know how to deserealize " + obj.getClass().getCanonicalName()); }
biMapper.unregister(Bytes.class); biMapper.unregister(dummy.getClass()); DefaultBiMapper.registerAdapter(dummy.getClass(), customByteArrayBiAdapter); DefaultBiMapper.registerAdapter(Bytes.class, customBytesBiAdapter); BiDeserializer bm = biMapper.newDeserializer(); contract = new Contract(); contract.deserialize(binder, bm); biMapper.unregister(Bytes.class); biMapper.unregister(dummy.getClass()); DefaultBiMapper.registerAdapter(dummy.getClass(), DefaultBiMapper.getByteArrayBiAdapter()); DefaultBiMapper.registerAdapter(Bytes.class, DefaultBiMapper.getBytesBiAdapter());
/** * Modify a map by deserializing it's values in place. Saves memory. * * @param map */ public void deserializeInPlace(Map map) { mapper.deserializeInPlace(map, this); }
/** * {@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)); }
return; Binder binder = DefaultBiMapper.getInstance().newSerializer().serialize(hm);
BiDeserializer bm = DefaultBiMapper.getInstance().newDeserializer(); binder.put("data", bm.deserialize(data));
/** * Try to deserialize map containing serialized object, e.g. having "__type" or "__t" key. Important. Is this * implementation can't deserialize the map, what usually means it has no known/properly serialized object in it, it * juts desearliazes it in place with {@link #deserializeInPlace(Map, BiDeserializer)} and return the same (but * updated) map instance. * * @param map possible containing the serialized object * @param <T> * * @return deserialized object or deserialized map */ public <T> T deserialize(Map map, BiDeserializer deserializer) { String typeName = (String) map.get("__type"); if (typeName == null) typeName = (String) map.get("__t"); if (typeName != null) { BiAdapter adapter = adapters.get(typeName); if (adapter != null) { return (T) adapter.deserialize(Binder.from(map), deserializer); } } deserializeInPlace(map, deserializer); return (T) map; }
/** * Deserialize a collection. Utility method that deserialize every object and return the result as an ArrayList. * * @param collection * @param <T> * * @return */ public <T> List<T> deserializeCollection(Collection<?> collection) { return collection.stream() .map(x -> (T) mapper.deserializeObject(x, this)) .collect(Collectors.toList()); }
/** * Try do serialize some object. Throws an exception if serialized form is tha same as not serialzied, as it means * that there is no suitable adapter to process. Be caeful because it will throw an exception also for the types * should not be serialized and this way are left intact. * * @param obj to try to serialize * @param <T> * * @return */ public <T> T serializeOrThrow(Object obj) { T result = mapper.serialize(obj, this); if (result == obj) throw new BiSerializationException("can't serialize " + obj); return result; } }
/** * 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)); }
/** * Update the map deserialziing it's values - e.g. in place. Saves memory but has strong side effects of discarding * source data. * * @param map to update * @param deserializer to use to deserialize map values */ public void deserializeInPlace(Map map, BiDeserializer deserializer) { map.forEach((key, value) -> { if (value instanceof Map) { String typeName = (String) ((Map) value).get("__type"); if (typeName == null) typeName = (String) ((Map) value).get("__t"); if (typeName == null) deserializeInPlace((Map) value, deserializer); else { BiAdapter adapter = adapters.get(typeName); if (adapter != null) { map.put(key, adapter.deserialize(Binder.from(value), deserializer)); } } } else if (value instanceof Collection) { map.put(key, ((Collection) value).stream() .map(x -> deserializer.deserialize(x)) .collect(Collectors.toList()) ); } }); }
public <T> T deserializeObject(Object x) { return x == null ? null : deserializeObject(x, new BiDeserializer(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); }
private boolean checkContractCorrespondsToConfig(Contract contract, List<NodeInfo> netNodes) { //check if contract contains net config if(!checkIfContractContainsNetConfig(contract)) { return false; } //check if net config equals to current network configuration List<NodeInfo> contractNodes = DefaultBiMapper.getInstance().deserializeObject(contract.getStateData().get("net_config")); if(contractNodes.size() != netNodes.size() || !contractNodes.stream().allMatch(nodeInfo -> netNodes.contains(nodeInfo))) { return false; } return true; }