Java Code Examples for org.nustaq.serialization.FSTConfiguration#createDefaultConfiguration()

public static FSTConfiguration getFST() {
  if (fst != null) {
    return fst;
  }
  FSTConfiguration conf = FSTConfiguration.createDefaultConfiguration();
  conf.registerClass(
      Project.class,
      ProjectDependency.class,
      GradleProject.class,
      MavenProject.class,
      MeghanadaProject.class,
      ParameterName.class,
      MethodParameterNames.class,
      Scope.class,
      LineRange.class,
      Position.class,
      Variable.class,
      Range.class,
      Source.class,
      MethodParameter.class,
      ClassIndex.class,
      MemberDescriptor.class);
  fst = conf;
  return fst;
}
 

public static void main(String[] args) throws Exception {
    FSTConfiguration conf = FSTConfiguration.createDefaultConfiguration();

    SomeMediumClass mediumClass = new SomeMediumClass();
    byte barray[] = conf.asByteArray(mediumClass);
    System.out.println(barray.length);
    SomeMediumClass object = (SomeMediumClass)conf.asObject(barray);
    System.out.println(object);


    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    FSTObjectOutput output = new FSTObjectOutput(outputStream);
    output.writeObject(mediumClass);
    output.close();

    FSTObjectInput input = new FSTObjectInput(new ByteArrayInputStream(outputStream.toByteArray()));
    object = (SomeMediumClass)input.readObject(SomeMediumClass.class);
    System.out.println(object);
}
 

/**
 * Initializes the delegate serializer
 */
private void initFST() {
    fastSerialConfig = FSTConfiguration.createDefaultConfiguration();
    if(classes != null) {
        fastSerialConfig.registerClass(classes);
    }
}
 

/**
 * Create a FST serializer (faster and more efficient than Java default serialization).
 * 
 * @param useUnsafe <code>true</code> to use <code>sun.misc.Unsafe</code> class, otherwise, a fallback is
 *            used.
 * @param securityProvider the security provider, needed to decode key pairs correctly
 */
public FSTSerializer(boolean useUnsafe, ISecurityClassProvider securityProvider) {
	if (!useUnsafe) {
		// don't use sun.misc.Unsafe class
		FSTUtil.unFlaggedUnsafe = null;
		logger.debug("Disabled the use of 'sun.misc.Unsafe' for the serialization");
	}

	fst = FSTConfiguration.createDefaultConfiguration();

	// register all often serialized classes for speedup. Note that every peer should have the same
	// configuration, which also depends on the order! Changing these registrations might break backward
	// compatibility!
	fst.registerClass(UserProfile.class, FolderIndex.class, FileIndex.class, UserPermission.class, Locations.class,
			UserPublicKey.class, MetaFileSmall.class, MetaFileLarge.class, FileVersion.class, MetaChunk.class,
			Chunk.class, EncryptedNetworkContent.class, ContactPeerMessage.class, ResponseMessage.class);

	// for all public / private keys for full compatibility among multiple security providers
	fst.registerClass(securityProvider.getRSAPublicKeyClass(), securityProvider.getRSAPrivateKeyClass(),
			securityProvider.getRSAPrivateCrtKeyClass());

	// for performance improvements, native TomP2P classes which are serialized quite often
	fst.registerClass(PeerAddress.class, PeerSocketAddress.class, Number160.class);

	// Since PeerAddresses are serialized very often, this is just an efficiency improvement
	fst.registerSerializer(PeerAddress.class, new FSTPeerAddressSerializer(), false);

	// register the acceptance reply enum
	fst.registerClass(AcceptanceReply.class);
}
 

public FSTConfiguration initialValue() {
	return FSTConfiguration.createDefaultConfiguration();
}
 

public GridNode(final GridRuntime gridRuntime, final Node localNode) {
  this.gridRuntime = gridRuntime;
  this.localNode = localNode;

  final FSTConfiguration conf = FSTConfiguration.createDefaultConfiguration();
  // set classloader with available proxy classes
  conf.setClassLoader(gridRuntime.worldClassLoader());

  final HardRefHolder holder = gridRuntime.world().actorFor(HardRefHolder.class,
      Definition.has(ExpiringHardRefHolder.class, ExpiringHardRefHolder::new));

  this.outbound =
          stage().actorFor(
                  GridActorControl.Outbound.class,
                  OutboundGridActorControl.class,
                  new OutboundGridActorControlInstantiator(
                                  localNode.id(),
                                  new FSTEncoder(conf),
                                  correlation::put,
                                  new OutBuffers(holder)));

  this.gridRuntime.setOutbound(outbound);

  final GridActorControl.Inbound inbound =
          stage().actorFor(
                  GridActorControl.Inbound.class,
                  InboundGridActorControl.class,
                  new InboundGridActorControlInstantiator(
                          gridRuntime,
                          correlation::remove));

  this.applicationMessageHandler =
          new GridApplicationMessageHandler(
                  localNode.id(),
                  gridRuntime.hashRing(),
                  inbound,
                  outbound,
                  new FSTDecoder(conf), holder,
                  scheduler());

  this.quorumObservers = new ArrayList<>(3);

  registerQuorumObserver(gridRuntime);
}
 

@Override
public FSTConfiguration load(Class<?> cls) throws Exception {
    return FSTConfiguration.createDefaultConfiguration();
}
 

public FSTSerializerImpl() {
    conf = FSTConfiguration.createDefaultConfiguration();
    conf.setForceSerializable(true);
}
 

@Override
public FSTConfiguration load(Class<?> cls) throws Exception {
    return FSTConfiguration.createDefaultConfiguration();
}
 

public static FSTConfiguration createFST() {
    FSTConfiguration fst = FSTConfiguration.createDefaultConfiguration();

    return fst;
}
 

@SuppressWarnings("unchecked")
private <T> T deepCopyPlain(T t) {
    FSTConfiguration fastSerialConfig = FSTConfiguration.createDefaultConfiguration();
    byte[] bytes = fastSerialConfig.asByteArray(t);
    return (T)fastSerialConfig.asObject(bytes);
}
 

public FstCodec() {
    this(FSTConfiguration.createDefaultConfiguration());
}
 

private static FSTConfiguration createConfig(ClassLoader classLoader) {
    FSTConfiguration def = FSTConfiguration.createDefaultConfiguration();
    def.setClassLoader(classLoader);
    return def;
}