public <E extends Embedding> E createEmbedding() { return (E) ReflectionUtils.newInstance(embeddingClass); }
/** * Create a user {@link org.apache.giraph.edge.OutEdges} used during * edge-based input * * @return Instantiated user input OutEdges */ public OutEdges<I, E> createInputOutEdges() { return ReflectionUtils.newInstance(getInputOutEdgesClass(), this); }
/** * Create new BlockFactory that is specified in the configuration. */ public static <S> BlockFactory<S> createBlockFactory(Configuration conf) { return ReflectionUtils.newInstance(BLOCK_FACTORY_CLASS.get(conf)); }
/** * Get the edge input filter to use * * @return EdgeInputFilter */ public EdgeInputFilter getEdgeInputFilter() { return ReflectionUtils.newInstance(getEdgeInputFilterClass(), this); }
/** * Create a user graph partitioner class * * @return Instantiated user graph partitioner class */ public GraphPartitionerFactory<I, V, E> createGraphPartitioner() { Class<? extends GraphPartitionerFactory<I, V, E>> klass = classes.getGraphPartitionerFactoryClass(); return ReflectionUtils.newInstance(klass, this); }
/** * Create a user vertex output format class. * Note: Giraph should only use WrappedVertexOutputFormat, * which makes sure that Configuration parameters are set properly. * * @return Instantiated user vertex output format class */ private VertexOutputFormat<I, V, E> createVertexOutputFormat() { Class<? extends VertexOutputFormat<I, V, E>> klass = getVertexOutputFormatClass(); return ReflectionUtils.newInstance(klass, this); }
/** * Create a user edge output format class. * Note: Giraph should only use WrappedEdgeOutputFormat, * which makes sure that Configuration parameters are set properly. * * @return Instantiated user edge output format class */ private EdgeOutputFormat<I, V, E> createEdgeOutputFormat() { Class<? extends EdgeOutputFormat<I, V, E>> klass = getEdgeOutputFormatClass(); return ReflectionUtils.newInstance(klass, this); }
@Override public Computation<I, V, E, Writable, Writable> createComputation( ImmutableClassesGiraphConfiguration<I, V, E> conf) { Class<? extends Computation> klass = conf.getComputationClass(); return ReflectionUtils.newInstance(klass, conf); }
/** * Get the vertex input filter to use * * @return VertexInputFilter */ public VertexInputFilter getVertexInputFilter() { return ReflectionUtils.newInstance(getVertexInputFilterClass(), this); }
/** * Get computation factory * * @return computation factory */ public ComputationFactory<I, V, E, ? extends Writable, ? extends Writable> createComputationFactory() { return ReflectionUtils.newInstance(getComputationFactoryClass(), this); }
/** * Create job retry checker * * @return GiraphJobRetryChecker set in configuration. */ public GiraphJobRetryChecker getJobRetryChecker() { return ReflectionUtils.newInstance(getJobRetryCheckerClass(), this); }
/** * Create a user edge input format class. * Note: Giraph should only use WrappedEdgeInputFormat, * which makes sure that Configuration parameters are set properly. * * @return Instantiated user edge input format class */ private EdgeInputFormat<I, E> createEdgeInputFormat() { Class<? extends EdgeInputFormat<I, E>> klass = getEdgeInputFormatClass(); return ReflectionUtils.newInstance(klass, this); }
/** * Create a user vertex revolver * * @return Instantiated user vertex resolver */ public VertexResolver<I, V, E> createVertexResolver() { return ReflectionUtils.newInstance(getVertexResolverClass(), this); }
/** * Create a user worker context * * @return Instantiated user worker context */ public WorkerContext createWorkerContext() { return ReflectionUtils.newInstance(getWorkerContextClass(), this); }
@Override public void readFields(DataInput dataInput) throws IOException { aggregationStorage = null; if (dataInput.readBoolean()) { Class<? extends AggregationStorage> aggregationStorageClass = WritableUtils.readClass(dataInput); aggregationStorage = ReflectionUtils.newInstance(aggregationStorageClass); aggregationStorage.readFields(dataInput); } }
/** * Create a {@link org.apache.giraph.mapping.MappingStore} instance * * @return MappingStore Instance */ public MappingStore<I, ? extends Writable> createMappingStore() { if (getMappingStoreClass() != null) { return ReflectionUtils.newInstance(getMappingStoreClass(), this); } else { return null; } }
/** * Create a {@link org.apache.giraph.mapping.MappingStoreOps} instance * * @return MappingStoreOps Instance */ public MappingStoreOps<I, ? extends Writable> createMappingStoreOps() { if (getMappingStoreOpsClass() != null) { return ReflectionUtils.newInstance(getMappingStoreOpsClass(), this); } else { return null; } }
/** * Get name of computation being run. We leave this up to the * {@link ComputationFactory} to decide what to return. * * @return Name of computation being run */ public String getComputationName() { ComputationFactory compFactory = ReflectionUtils.newInstance( getComputationFactoryClass()); return compFactory.computationName(this); }
/** * Read Fields. * * @param input Input to be read. * @throws IOException for IO. */ public void readFields(final DataInput input) throws IOException { sourceId = (I) ReflectionUtils.newInstance(getVertexIdClass(), conf); sourceId.readFields(input); message = (M) ReflectionUtils.newInstance(getMessageClass(), conf); message.readFields(input); }
@Override public void readFields(DataInput in) throws IOException { aggregatorClass = WritableUtils.readClass(in); value = ReflectionUtils.newInstance(aggregatorClass, getConf()) .createInitialValue(); value.readFields(in); } }