public <E extends Embedding> E createEmbedding() { return (E) ReflectionUtils.newInstance(embeddingClass); }
@Override public void verifyConsistent( ImmutableClassesGiraphConfiguration conf) { Class<?>[] factoryTypes = ReflectionUtils.getTypeArguments( MessageValueFactory.class, messageValueFactoryClass); ReflectionUtils.verifyTypes(messageClass, factoryTypes[0], "Message factory", messageValueFactoryClass); if (messageCombinerClass != null) { Class<?>[] combinerTypes = ReflectionUtils.getTypeArguments( MessageCombiner.class, messageCombinerClass); ReflectionUtils.verifyTypes(conf.getVertexIdClass(), combinerTypes[0], "Vertex id", messageCombinerClass); ReflectionUtils.verifyTypes(messageClass, combinerTypes[1], "Outgoing message", messageCombinerClass); } }
/** * Get package path to the object given. Used with resources. * * @param object the Object to check * @return Path to package of object */ public static String getPackagePath(Object object) { return getPackagePath(object.getClass()); }
final Class<? extends Writable> getOutgoingMessage() { if (newMessage != null) { return newMessage; } if (newComputationClass == null) { return originalMessage; } Class[] computationTypes = ReflectionUtils.getTypeArguments( TypesHolder.class, newComputationClass); return computationTypes[4]; }
/** * Verify that found type matches the expected type. If types don't match an * {@link IllegalStateException} will be thrown. * * @param concreteChild Concrete child type * @param parent Parent type * @param typeDesc String description of the type (for exception description) * @param mainClass Class in which the actual type was found (for exception * description) */ public static void verifyTypes(Class<?> concreteChild, Class<?> parent, String typeDesc, Class<?> mainClass) { // unknown means object if (parent == TypeResolver.Unknown.class) { parent = Object.class; } verifyConcrete(concreteChild, typeDesc); if (!parent.isAssignableFrom(concreteChild)) { throw new IllegalStateException("verifyTypes: " + typeDesc + " types " + "don't match, in " + mainClass.getName() + " " + concreteChild + " expected, but " + parent + " found"); } }
/** * Infer types from Computation class * * @param klass Computation class */ public void inferFrom(Class<? extends TypesHolder> klass) { Class<?>[] classList = getTypeArguments(TypesHolder.class, klass); Preconditions.checkArgument(classList.length == 5); vertexIdClass = (Class<I>) classList[0]; vertexValueClass = (Class<V>) classList[1]; edgeValueClass = (Class<E>) classList[2]; outgoingMessageValueClass = (Class<? extends Writable>) classList[4]; }
@Override public M newInstance() { return ReflectionUtils.newInstance(klass); } }
void sanityTypeChecks( GiraphConfiguration conf, Class<?> previousMessageClass) { if (computationClass != null) { final Class<?> vertexIdClass = GiraphConstants.VERTEX_ID_CLASS.get(conf); final Class<?> vertexValueClass = GiraphConstants.VERTEX_VALUE_CLASS.get(conf); final Class<?> edgeValueClass = GiraphConstants.EDGE_VALUE_CLASS.get(conf); Class<?>[] classList = getTypeArguments( TypesHolder.class, computationClass); Preconditions.checkArgument(classList.length == 5); ReflectionUtils.verifyTypes( vertexIdClass, classList[0], "vertexId", computationClass); ReflectionUtils.verifyTypes( vertexValueClass, classList[1], "vertexValue", computationClass); ReflectionUtils.verifyTypes( edgeValueClass, classList[2], "edgeValue", computationClass); if (previousMessageClass != null) { ReflectionUtils.verifyTypes( previousMessageClass, classList[3], "recvMessage", computationClass); } ReflectionUtils.verifyTypes( messageClass, classList[4], "sendMessage", computationClass); } }
/** * Get mappingTarget class * * @return mappingTarget class */ public Class<? extends Writable> getMappingTargetClass() { if (mappingTargetClass == null) { Class<?>[] classList = ReflectionUtils.getTypeArguments( MappingStore.class, getMappingStoreClass()); Preconditions.checkArgument(classList.length == 2); mappingTargetClass = (Class<? extends Writable>) classList[1]; } return mappingTargetClass; }
} else { deployType = DeployType.RESOURCE; script = ReflectionUtils.getPackagePath(this) + "/page-rank.py";
/** * Used by {@link #read(Kryo, Input, Class)} to create the new object. * This can be overridden to customize object creation, eg to call a * constructor with arguments. The default implementation * uses {@link Kryo#newInstance(Class)}. * * @param kryo Kryo object instance * @param input Input * @param type Type of the class to create * @return New instance of wanted type */ protected T create(Kryo kryo, Input input, Class<T> type) { return ReflectionUtils.newInstance(type); } }
@Override public void apply(AbstractPiece piece) { if (!piece.getClass().equals(Piece.class)) { Class<?>[] classList = getTypeArguments( AbstractPiece.class, piece.getClass()); Preconditions.checkArgument(classList.length == 7); ReflectionUtils.verifyTypes( vertexIdClass, classList[0], "vertexId", piece.getClass()); ReflectionUtils.verifyTypes( vertexValueClass, classList[1], "vertexValue", piece.getClass()); ReflectionUtils.verifyTypes( edgeValueClass, classList[2], "edgeValue", piece.getClass()); MessageClasses classes = piece.getMessageClasses(conf); Class<?> messageType = classes.getMessageClass(); if (messageType == null) { messageType = NoMessage.class; } ReflectionUtils.verifyTypes( messageType, classList[3], "message", piece.getClass()); ReflectionUtils.verifyTypes( workerContextValueClass, classList[4], "workerContextValue", piece.getClass()); // No need to check worker context message class at all ReflectionUtils.verifyTypes( executionStageClass, classList[6], "executionStage", piece.getClass()); } } });
/** * Set computation class * @param computationClass computation class */ public void setComputationClass( Class<? extends Computation> computationClass) { this.computationClass = computationClass; if (computationClass != null) { Class[] computationTypes = ReflectionUtils.getTypeArguments( TypesHolder.class, computationClass); if (computationTypes[4] != null && outgoingMessageClasses instanceof DefaultMessageClasses) { ((DefaultMessageClasses) outgoingMessageClasses) .setIfNotModifiedMessageClass(computationTypes[4]); } } }
public MasterComputation createMasterComputation() { return ReflectionUtils.newInstance(masterComputationClass); }
@Override public void verifyConsistent(ImmutableClassesGiraphConfiguration conf) { MessageValueFactory<M> messageValueFactory = messageValueFactorySupplier.apply(conf); Preconditions.checkState( messageValueFactory.newInstance().getClass().equals(messageClass)); if (messageCombinerSupplier != null) { MessageCombiner<? super I, M> messageCombiner = messageCombinerSupplier.apply(conf); Preconditions.checkState(messageCombiner.createInitialMessage() .getClass().equals(messageClass)); Class<?>[] combinerTypes = ReflectionUtils.getTypeArguments( MessageCombiner.class, messageCombiner.getClass()); ReflectionUtils.verifyTypes(conf.getVertexIdClass(), combinerTypes[0], "Vertex id", messageCombiner.getClass()); ReflectionUtils.verifyTypes(messageClass, combinerTypes[1], "Outgoing message", messageCombiner.getClass()); } } }
/** Verify that the vertex value factory's type matches the job */ private void verifyVertexValueFactoryGenericTypes() { Class<? extends VertexValueFactory<V>> vvfClass = conf.getVertexValueFactoryClass(); if (DefaultVertexValueFactory.class.equals(vvfClass)) { return; } Class<?>[] classList = getTypeArguments(VertexValueFactory.class, vvfClass); checkEquals(classList, VALUE_PARAM_VERTEX_VALUE_FACTORY_INDEX, vertexValueType(), VertexValueFactory.class, "vertex value"); }
public <O extends Embedding> Computation<O> createComputation() { return ReflectionUtils.newInstance(computationClass); }
Class<?>[] computationTypes = ReflectionUtils.getTypeArguments( TypesHolder.class, computationClass); ReflectionUtils.verifyTypes(conf.getVertexIdClass(), computationTypes[0], "Vertex id", computationClass); ReflectionUtils.verifyTypes(conf.getVertexValueClass(), computationTypes[1], "Vertex value", computationClass); ReflectionUtils.verifyTypes(conf.getEdgeValueClass(), computationTypes[2], "Edge value", computationClass); ReflectionUtils.verifyTypes(incomingMessageClasses.getMessageClass(), computationTypes[3], "Incoming message type", computationClass); ReflectionUtils.verifyTypes(outgoingMessageClasses.getMessageClass(), computationTypes[4], "Outgoing message type", computationClass);
/** * If there is a vertex value combiner type, verify its * generic params match the job. */ private void verifyVertexValueCombinerGenericTypes() { Class<? extends VertexValueCombiner<V>> vertexValueCombiner = conf.getVertexValueCombinerClass(); if (vertexValueCombiner != null) { Class<?>[] classList = getTypeArguments(VertexValueCombiner.class, vertexValueCombiner); checkAssignable(classList, VALUE_PARAM_VERTEX_VALUE_COMBINER_INDEX, vertexValueType(), VertexValueCombiner.class, "vertex value"); } }
/** * 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); }