Examples with Input com.esotericsoftware.kryo.io.Input used on opensource projects

Example 11 with Input

use of com.esotericsoftware.kryo.io.Input in project apex-core by apache.

the class Journal method replay.

final void replay(final InputStream input) {
    if (replayMode.compareAndSet(false, true)) {
        Input in = new Input(input);
        try {
            LOG.debug("Start replaying WAL");
            while (!in.eof()) {
                final int opId = in.readInt();
                final RecoverableOperation recoverableOperation = RecoverableOperation.get(opId);
                if (recoverableOperation == null) {
                    throw new IllegalArgumentException("No reader registered for id " + opId);
                }
                LOG.debug("Replaying {}", recoverableOperation);
                switch(recoverableOperation) {
                    case OPERATOR_STATE:
                    case CONTAINER_STATE:
                        recoverableOperation.operation.read(scm.getPhysicalPlan(), in);
                        break;
                    case OPERATOR_PROPERTY:
                    case PHYSICAL_OPERATOR_PROPERTY:
                        recoverableOperation.operation.read(scm, in);
                        break;
                    default:
                        throw new IllegalArgumentException("Unsupported recoverable operation " + recoverableOperation);
                }
            }
        } finally {
            LOG.debug("Done replaying WAL");
            replayMode.set(false);
        }
    } else {
        throw new IllegalStateException("Request to replay while journal is already replaying other operations");
    }
}

Example 12 with Input

use of com.esotericsoftware.kryo.io.Input in project apex-core by apache.

the class FSStorageAgent method retrieve.

public static Object retrieve(InputStream stream) {
    synchronized (kryo) {
        kryo.setClassLoader(Thread.currentThread().getContextClassLoader());
        Input input = new Input(stream);
        return kryo.readClassAndObject(input);
    }
}

Example 13 with Input

use of com.esotericsoftware.kryo.io.Input in project heron by twitter.

the class HeronPluggableSerializerDelegate method initialize.

@Override
@SuppressWarnings("rawtypes")
public void initialize(Map config) {
    kryo = SerializationFactory.getKryo(config);
    kryoOut = new Output(2000, 2000000000);
    kryoIn = new Input(1);
}

Example 14 with Input

use of com.esotericsoftware.kryo.io.Input in project intellij-community by JetBrains.

the class ExternalProjectSerializer method load.

@Nullable
public ExternalProject load(@NotNull ProjectSystemId externalSystemId, File externalProjectPath) {
    LOG.debug("Attempt to load project data from: " + externalProjectPath);
    ExternalProject externalProject = null;
    try {
        final File configurationFile = getProjectConfigurationFile(externalSystemId, externalProjectPath);
        if (!configurationFile.isFile())
            return null;
        Input input = new Input(new FileInputStream(configurationFile));
        try {
            externalProject = myKryo.readObject(input, DefaultExternalProject.class);
        } finally {
            StreamUtil.closeStream(input);
        }
    } catch (Exception e) {
        LOG.debug(e);
    }
    if (externalProject != null) {
        LOG.debug("Loaded project: " + externalProject.getProjectDir());
    }
    return externalProject;
}

Example 15 with Input

use of com.esotericsoftware.kryo.io.Input in project intellij-community by JetBrains.

the class ExternalProjectSerializer method configureKryo.

private void configureKryo() {
    myKryo.setAutoReset(true);
    myKryo.setRegistrationRequired(true);
    Log.set(Log.LEVEL_WARN);
    myKryo.register(ArrayList.class, new CollectionSerializer() {

        @Override
        protected Collection create(Kryo kryo, Input input, Class<Collection> type) {
            return new ArrayList();
        }
    });
    myKryo.register(HashMap.class, new MapSerializer() {

        @Override
        protected Map create(Kryo kryo, Input input, Class<Map> type) {
            return new HashMap();
        }
    });
    myKryo.register(HashSet.class, new CollectionSerializer() {

        @Override
        protected Collection create(Kryo kryo, Input input, Class<Collection> type) {
            return new HashSet();
        }
    });
    myKryo.register(File.class, new FileSerializer());
    myKryo.register(DefaultExternalProject.class, new FieldSerializer<DefaultExternalProject>(myKryo, DefaultExternalProject.class) {

        @Override
        protected DefaultExternalProject create(Kryo kryo, Input input, Class<DefaultExternalProject> type) {
            return new DefaultExternalProject();
        }
    });
    myKryo.register(DefaultExternalTask.class, new FieldSerializer<DefaultExternalTask>(myKryo, DefaultExternalTask.class) {

        @Override
        protected DefaultExternalTask create(Kryo kryo, Input input, Class<DefaultExternalTask> type) {
            return new DefaultExternalTask();
        }
    });
    myKryo.register(DefaultExternalPlugin.class, new FieldSerializer<DefaultExternalPlugin>(myKryo, DefaultExternalPlugin.class) {

        @Override
        protected DefaultExternalPlugin create(Kryo kryo, Input input, Class<DefaultExternalPlugin> type) {
            return new DefaultExternalPlugin();
        }
    });
    myKryo.register(DefaultExternalSourceSet.class, new FieldSerializer<DefaultExternalSourceSet>(myKryo, DefaultExternalSourceSet.class) {

        @Override
        protected DefaultExternalSourceSet create(Kryo kryo, Input input, Class<DefaultExternalSourceSet> type) {
            return new DefaultExternalSourceSet();
        }
    });
    myKryo.register(DefaultExternalSourceDirectorySet.class, new FieldSerializer<DefaultExternalSourceDirectorySet>(myKryo, DefaultExternalSourceDirectorySet.class) {

        @Override
        protected DefaultExternalSourceDirectorySet create(Kryo kryo, Input input, Class<DefaultExternalSourceDirectorySet> type) {
            return new DefaultExternalSourceDirectorySet();
        }
    });
    myKryo.register(DefaultExternalFilter.class, new FieldSerializer<DefaultExternalFilter>(myKryo, DefaultExternalFilter.class) {

        @Override
        protected DefaultExternalFilter create(Kryo kryo, Input input, Class<DefaultExternalFilter> type) {
            return new DefaultExternalFilter();
        }
    });
    myKryo.register(ExternalSystemSourceType.class, new DefaultSerializers.EnumSerializer(ExternalSystemSourceType.class));
    myKryo.register(DefaultExternalProjectDependency.class, new FieldSerializer<DefaultExternalProjectDependency>(myKryo, DefaultExternalProjectDependency.class) {

        @Override
        protected DefaultExternalProjectDependency create(Kryo kryo, Input input, Class<DefaultExternalProjectDependency> type) {
            return new DefaultExternalProjectDependency();
        }
    });
    myKryo.register(DefaultFileCollectionDependency.class, new FieldSerializer<DefaultFileCollectionDependency>(myKryo, DefaultFileCollectionDependency.class) {

        @Override
        protected DefaultFileCollectionDependency create(Kryo kryo, Input input, Class<DefaultFileCollectionDependency> type) {
            return new DefaultFileCollectionDependency();
        }
    });
    myKryo.register(DefaultExternalLibraryDependency.class, new FieldSerializer<DefaultExternalLibraryDependency>(myKryo, DefaultExternalLibraryDependency.class) {

        @Override
        protected DefaultExternalLibraryDependency create(Kryo kryo, Input input, Class<DefaultExternalLibraryDependency> type) {
            return new DefaultExternalLibraryDependency();
        }
    });
    myKryo.register(DefaultUnresolvedExternalDependency.class, new FieldSerializer<DefaultUnresolvedExternalDependency>(myKryo, DefaultUnresolvedExternalDependency.class) {

        @Override
        protected DefaultUnresolvedExternalDependency create(Kryo kryo, Input input, Class<DefaultUnresolvedExternalDependency> type) {
            return new DefaultUnresolvedExternalDependency();
        }
    });
    myKryo.register(DefaultExternalDependencyId.class, new FieldSerializer<DefaultExternalDependencyId>(myKryo, DefaultExternalDependencyId.class) {

        @Override
        protected DefaultExternalDependencyId create(Kryo kryo, Input input, Class<DefaultExternalDependencyId> type) {
            return new DefaultExternalDependencyId();
        }
    });
    myKryo.register(LinkedHashSet.class, new CollectionSerializer() {

        @Override
        protected Collection create(Kryo kryo, Input input, Class<Collection> type) {
            return new LinkedHashSet();
        }
    });
    myKryo.register(HashSet.class, new CollectionSerializer() {

        @Override
        protected Collection create(Kryo kryo, Input input, Class<Collection> type) {
            return new HashSet();
        }
    });
    myKryo.register(THashSet.class, new CollectionSerializer() {

        @Override
        protected Collection create(Kryo kryo, Input input, Class<Collection> type) {
            return new THashSet();
        }
    });
    myKryo.register(Set.class, new CollectionSerializer() {

        @Override
        protected Collection create(Kryo kryo, Input input, Class<Collection> type) {
            return new HashSet();
        }
    });
    myKryo.register(THashMap.class, new MapSerializer() {

        @Override
        protected Map create(Kryo kryo, Input input, Class<Map> type) {
            return new THashMap();
        }
    });
}