public <T> T deepCopy(T metadata) { return (T) asObject(asByteArray(metadata)); }
/** * throw * @param preregister */ public OffHeapCoder( boolean sharedRefs, Class ... preregister ) { this(sharedRefs); conf.registerClass(preregister); }
private static FSTConfiguration copy(ClassLoader classLoader, FstCodec codec) { FSTConfiguration def = FSTConfiguration.createDefaultConfiguration(); def.setClassLoader(classLoader); def.setCoderSpecific(codec.config.getCoderSpecific()); def.setCrossPlatform(codec.config.isCrossPlatform()); def.setForceClzInit(codec.config.isForceClzInit()); def.setForceSerializable(codec.config.isForceSerializable()); def.setInstantiator(codec.config.getInstantiator(null)); def.setName(codec.config.getName()); def.setPreferSpeed(codec.config.isPreferSpeed()); def.setShareReferences(codec.config.isShareReferences()); def.setStreamCoderFactory(codec.config.getStreamCoderFactory()); def.setVerifier(codec.config.getVerifier()); return def; }
private static FSTConfiguration createConfig(ClassLoader classLoader) { FSTConfiguration def = FSTConfiguration.createDefaultConfiguration(); def.setClassLoader(classLoader); return def; }
public static <T> T unserialize(byte[] bytes) { return (T) CONFIGURATION.asObject(bytes); }
public static <T> byte[] serialize(T value) { return CONFIGURATION.asByteArray(value); }
public OnHeapCoder(boolean sharedRefs) { conf = FSTConfiguration.createUnsafeBinaryConfiguration(); conf.setShareReferences(sharedRefs); writeTarget = new HeapBytez(new byte[0]); readTarget = new HeapBytez(new byte[0]); conf.setStreamCoderFactory(new FSTConfiguration.StreamCoderFactory() { @Override public FSTEncoder createStreamEncoder() { out = conf.getObjectOutput(); in = conf.getObjectInput(); } else { out = new FSTObjectOutputNoShared(conf);
/** * utility/debug method. Use "asByteArray" for programmatic use as the * byte array will already by UTF-8 and ready to be sent on network. * * @param o * @return */ public String asJsonString(Object o) { if ( getCoderSpecific() instanceof JsonFactory == false ) { return "can be called on JsonConfiguration only"; } else { return new String(asByteArray(o), StandardCharsets.UTF_8); } }
public FSTObjectInput getObjectInput(InputStream inputStream) { return conf.getObjectInput(inputStream); } }
public FSTObjectOutput getObjectOutput(OutputStream outputStream) { return conf.getObjectOutput(outputStream); }
public DefaultCoder(boolean shared, Class ... toPreRegister) { conf = FSTConfiguration.createDefaultConfiguration(); conf.setShareReferences(shared); if ( toPreRegister != null && toPreRegister.length > 0 ) { conf.registerClass(toPreRegister); } if ( shared ) { input = new FSTObjectInput(conf); output = new FSTObjectOutput(conf); } else { input = new FSTObjectInputNoShared(conf); output = new FSTObjectOutputNoShared(conf); } }
public TCPObjectServer(int port) { this.conf = FSTConfiguration.createDefaultConfiguration(); this.port = port; }
protected static FSTConfiguration createConfiguration(ConfType ct, boolean shareRefs,ConcurrentHashMap<FieldKey, FSTClazzInfo.FSTFieldInfo> shared ) { FSTConfiguration res; switch (ct) { case DEFAULT: res = createDefaultConfiguration(shared); break; case MINBIN: res = createMinBinConfiguration(shared); break; case UNSAFE: res = createUnsafeBinaryConfiguration(shared); break; case JSON: res = createJsonConfiguration( false, shareRefs, shared); break; case JSONPRETTY: res = createJsonConfiguration( true, shareRefs, shared); break; default: throw new RuntimeException("unsupported conftype for factory method"); } res.setShareReferences(shareRefs); return res; } /**
protected static FSTConfiguration createMinBinConfiguration(ConcurrentHashMap<FieldKey, FSTClazzInfo.FSTFieldInfo> shared) { final FSTConfiguration res = createDefaultConfiguration(shared); res.setCrossPlatform(true); res.type = ConfType.MINBIN; res.setStreamCoderFactory(new MinBinStreamCoderFactory(res)); reg.putSerializer(AbstractMap.class, new FSTMapSerializer(), true); // subclass should register manually res.registerCrossPlatformClassMapping(new String[][]{ {"map", HashMap.class.getName()}, {"list", ArrayList.class.getName()}, {"float[]", "[F"} }); res.registerSerializer( BigDecimal.class, new FSTJSonSerializers.BigDecSerializer(), true ); return res;
protected void configureSerialization(Coding code) { conf.registerSerializer(Actor.class,new ActorRefSerializer(this),true); conf.registerSerializer(CallbackWrapper.class, new CallbackRefSerializer(this), true); conf.registerSerializer(Spore.class, new SporeRefSerializer(), true); conf.registerSerializer(Timeout.class, new TimeoutSerializer(), false); conf.registerClass(RemoteCallEntry.class); conf.registerClass(Spore.class); conf.registerClass(CallbackWrapper.class); conf.registerClass(Actor.class); }
/** * Initializes the delegate serializer */ private void initFST() { fastSerialConfig = FSTConfiguration.createDefaultConfiguration(); if(classes != null) { fastSerialConfig.registerClass(classes); } }
protected static FSTConfiguration createUnsafeBinaryConfiguration(ConcurrentHashMap<FieldKey, FSTClazzInfo.FSTFieldInfo> shared) { if ( isAndroid ) throw new RuntimeException("not supported under android platform, use default configuration"); final FSTConfiguration conf = FSTConfiguration.createDefaultConfiguration(shared); conf.type = ConfType.UNSAFE; conf.setStreamCoderFactory(new FBinaryStreamCoderFactory(conf)); return conf; }
@Override public <T> T deserialize(byte[] bytes, Class<T> clz) throws IOException { if (bytes == null || bytes.length == 0) { return null; } return (T) fst.asObject(bytes); }
@Override public byte[] serialize(Object obj) { if (obj == null) return null; return fst.asByteArray(obj); }
public OffHeapCoder(boolean sharedRefs) { conf = FSTConfiguration.createUnsafeBinaryConfiguration(); conf.setShareReferences(sharedRefs); writeTarget = new MallocBytez(0l,0); readTarget = new MallocBytez(0l,0); conf.setStreamCoderFactory(new FSTConfiguration.StreamCoderFactory() { @Override public FSTEncoder createStreamEncoder() { out = conf.getObjectOutput(); in = conf.getObjectInput(); } else { out = new FSTObjectOutputNoShared(conf);