/** * Get the vertex edges class * * @return vertex edges class */ public Class<? extends OutEdges> getOutEdgesClass() { return VERTEX_EDGES_CLASS.get(this); }
/** * Set which BlockFactory class to be used for the application. * (generally useful within tests only) */ public static void setBlockFactoryClass(Configuration conf, Class<? extends BlockFactory<?>> clazz) { BLOCK_FACTORY_CLASS.set(conf, clazz); }
/** * Add class to list for key * * @param conf Configuration * @param klass Class to add */ public void add(Configuration conf, Class<? extends C> klass) { addToClasses(conf, getKey(), klass, interfaceClass); }
@Override public final void initConfig(GiraphConfiguration conf) { initConfigurators(conf); GiraphConstants.VERTEX_ID_CLASS.setIfUnset(conf, getVertexIDClass(conf)); GiraphConstants.VERTEX_VALUE_CLASS.setIfUnset( conf, getVertexValueClass(conf)); GiraphConstants.EDGE_VALUE_CLASS.setIfUnset(conf, getEdgeValueClass(conf)); GiraphConstants.RESOLVER_CREATE_VERTEX_ON_MSGS.setIfUnset( conf, shouldCreateVertexOnMsgs(conf)); BlockUtils.BLOCK_WORKER_CONTEXT_VALUE_CLASS.setIfUnset( conf, getWorkerContextValueClass(conf)); if (!GiraphConstants.VERTEX_EDGES_CLASS.contains(conf)) { @SuppressWarnings("rawtypes") Class<? extends WritableComparable> vertexIDClass = GiraphConstants.VERTEX_ID_CLASS.get(conf); Class<? extends Writable> edgeValueClass = GiraphConstants.EDGE_VALUE_CLASS.get(conf); if (edgeValueClass.equals(NullWritable.class)) { if (vertexIDClass.equals(LongWritable.class)) { GiraphConstants.VERTEX_EDGES_CLASS.set( conf, LongDiffNullArrayEdges.class); } else if (idTypeOps != null) { GiraphConstants.VERTEX_EDGES_CLASS.set( conf, IdAndNullArrayEdges.class); TypeOpsUtils.getTypeOpsOrNull(edgeValueClass); if (edgeValueTypeOps != null && idTypeOps != null) {
GiraphConstants.OUTGOING_MESSAGE_VALUE_CLASS.get(conf) == null, "Message types should only be specified in Pieces, " + "but outgoing was specified globally"); Preconditions.checkState( GiraphConstants.OUTGOING_MESSAGE_VALUE_FACTORY_CLASS .isDefaultValue(conf), "Message types should only be specified in Pieces, " + "but factory was specified globally"); Preconditions.checkState( GiraphConstants.MESSAGE_COMBINER_CLASS.get(conf) == null, "Message combiner should only be specified in Pieces, " + "but was specified globally"); GiraphConstants.OUTGOING_MESSAGE_VALUE_CLASS.get(conf) == null, "Outgoing message type was specified in blockFactory.initConfig"); Preconditions.checkState( GiraphConstants.OUTGOING_MESSAGE_VALUE_FACTORY_CLASS .isDefaultValue(conf), "Outgoing message factory type was specified in " + "blockFactory.initConfig"); Preconditions.checkState( GiraphConstants.MESSAGE_COMBINER_CLASS.get(conf) == null, "Message combiner type was specified in blockFactory.initConfig"); GiraphConstants.OUTGOING_MESSAGE_VALUE_CLASS.set(conf, NoMessage.class);
(Class<? extends ComputationFactory<I, V, E, ? extends Writable, ? extends Writable>>) COMPUTATION_FACTORY_CLASS.get(conf); computationClass = (Class<? extends Computation<I, V, E, ? extends Writable, ? extends Writable>>) COMPUTATION_CLASS.get(conf); VERTEX_EDGES_CLASS.get(conf); inputOutEdgesClass = (Class<? extends OutEdges<I, E>>) INPUT_VERTEX_EDGES_CLASS.getWithDefault(conf, outEdgesClass); GRAPH_PARTITIONER_FACTORY_CLASS.get(conf); VERTEX_INPUT_FORMAT_CLASS.get(conf); vertexOutputFormatClass = (Class<? extends VertexOutputFormat<I, V, E>>) VERTEX_OUTPUT_FORMAT_CLASS.get(conf); edgeInputFormatClass = (Class<? extends EdgeInputFormat<I, E>>) EDGE_INPUT_FORMAT_CLASS.get(conf); edgeOutputFormatClass = (Class<? extends EdgeOutputFormat<I, V, E>>) EDGE_OUTPUT_FORMAT_CLASS.get(conf); mappingInputFormatClass = (Class<? extends MappingInputFormat<I, V, E, ? extends Writable>>) MAPPING_INPUT_FORMAT_CLASS.get(conf); aggregatorWriterClass = AGGREGATOR_WRITER_CLASS.get(conf); outgoingMessageClasses = new DefaultMessageClasses( giraphTypes.getInitialOutgoingMessageValueClass(),
/** * Constructor reading from Configuration * * @param conf Configuration to read from */ public ValueFactories(Configuration conf) { vertexIdFactory = VERTEX_ID_FACTORY_CLASS.newInstance(conf); vertexValueFactory = VERTEX_VALUE_FACTORY_CLASS.newInstance(conf); edgeValueFactory = EDGE_VALUE_FACTORY_CLASS.newInstance(conf); }
/** * Write types to Configuration if not already set * * @param conf Configuration */ public void writeIfUnset(Configuration conf) { VERTEX_ID_CLASS.setIfUnset(conf, vertexIdClass); VERTEX_VALUE_CLASS.setIfUnset(conf, vertexValueClass); EDGE_VALUE_CLASS.setIfUnset(conf, edgeValueClass); OUTGOING_MESSAGE_VALUE_CLASS.setIfUnset(conf, outgoingMessageValueClass); }
/** * Add a MapperObserver class (optional) * * @param mapperObserverClass MapperObserver class to add. */ public final void addMapperObserverClass( Class<? extends MapperObserver> mapperObserverClass) { MAPPER_OBSERVER_CLASSES.add(this, mapperObserverClass); }
/** * Get array of MapperObserver classes set in configuration. * * @return array of MapperObserver classes. */ public Class<? extends MapperObserver>[] getMapperObserverClasses() { return MAPPER_OBSERVER_CLASSES.getArray(this); }
/** * Static create method * * @param key key * @param defaultClass default class * @param interfaceClass interface class * @param description configuration description * @param <T> type of class * @return ClassConfOption */ public static <T> ClassConfOption<T> create(String key, Class<? extends T> defaultClass, Class<T> interfaceClass, String description) { return new ClassConfOption<T>(key, defaultClass, interfaceClass, description); }
public void preApplication(BlockWorkerContextApi api, BlockOutputHandle outputHandle) { workerValue = BlockUtils.BLOCK_WORKER_CONTEXT_VALUE_CLASS.newInstance(api.getConf()); this.outputHandle = outputHandle; }
/** * Add a MasterObserver class (optional) * * @param masterObserverClass MasterObserver class to add. */ public final void addMasterObserverClass( Class<? extends MasterObserver> masterObserverClass) { MASTER_OBSERVER_CLASSES.add(this, masterObserverClass); }
/** * Get array of MasterObserver classes set in the configuration. * * @return array of MasterObserver classes. */ public Class<? extends MasterObserver>[] getMasterObserverClasses() { return MASTER_OBSERVER_CLASSES.getArray(this); }
/** * Set the vertex input filter class * * @param vertexFilterClass class to use */ public void setVertexInputFilterClass( Class<? extends VertexInputFilter> vertexFilterClass) { VERTEX_INPUT_FILTER_CLASS.set(this, vertexFilterClass); }
/** * Get the class used for edge translation during vertex input * * @return edge translation class */ public Class<? extends TranslateEdge> edgeTranslationClass() { return EDGE_TRANSLATION_CLASS.get(this); }
/** * Create job progress server on job client if enabled in configuration. * * @param conf Configuration * @param jobObserver Giraph job callbacks * @return JobProgressTrackerService */ public static JobProgressTrackerService createJobProgressTrackerService( GiraphConfiguration conf, GiraphJobObserver jobObserver) { if (!conf.trackJobProgressOnClient()) { return null; } JobProgressTrackerService jobProgressTrackerService = GiraphConstants.JOB_PROGRESS_TRACKER_CLASS.newInstance(conf); jobProgressTrackerService.init(conf, jobObserver); return jobProgressTrackerService; } }
/** * Add a WorkerObserver class (optional) * * @param workerObserverClass WorkerObserver class to add. */ public final void addWorkerObserverClass( Class<? extends WorkerObserver> workerObserverClass) { WORKER_OBSERVER_CLASSES.add(this, workerObserverClass); }
/** * Get array of WorkerObserver classes set in configuration. * * @return array of WorkerObserver classes. */ public Class<? extends WorkerObserver>[] getWorkerObserverClasses() { return WORKER_OBSERVER_CLASSES.getArray(this); }