private ModelReference<?> mapSubject(ModelReference<?> subject, ModelPath targetPath) { if (subject.getPath() == null) { return subject.inScope(targetPath); } else { return subject.withPath(targetPath.descendant(subject.getPath())); } }
private void mapInputs(List<ModelReference<?>> inputs, ModelPath targetPath) { for (int i = 0; i < inputs.size(); i++) { ModelReference<?> input = inputs.get(i); if (input.getPath() != null) { inputs.set(i, input.withPath(targetPath.descendant(input.getPath()))); } else { inputs.set(i, input.inScope(ModelPath.ROOT)); } } }
public RegistrationAction( ModelType<? extends ComponentSpec> publicType, ModelType<? extends BaseComponentSpec> implementationType, Set<Class<?>> internalViews, ModelRuleDescriptor descriptor) { super( ModelReference.of(ComponentSpecFactory.class), descriptor, ModelReference.of("serviceRegistry", ServiceRegistry.class), ModelReference.of("projectIdentifier", ProjectIdentifier.class), ModelReference.of("sources", ProjectSourceSet.class)); this.publicType = publicType; this.implementationType = implementationType; this.internalViews = internalViews; }
@Override public List<ModelReference<?>> getInputs() { return ImmutableList.<ModelReference<?>>builder() .add(ModelReference.of(ITaskFactory.class)) .addAll(super.getInputs()) .build(); }
private <R, S extends BinarySpec> ExtractedModelRule createRegistration( MethodRuleDefinition<R, ?> ruleDefinition) { try { RuleMethodDataCollector dataCollector = new RuleMethodDataCollector(); verifyMethodSignature(dataCollector, ruleDefinition); final Class<S> binaryType = dataCollector.getParameterType(BinarySpec.class); final BinaryTaskRule<R, S> binaryTaskRule = new BinaryTaskRule<R, S>(binaryType, ruleDefinition); return new ExtractedModelAction( ModelActionRole.Defaults, ImmutableList.of(ComponentModelBasePlugin.class), DirectNodeNoInputsModelAction.of( ModelReference.of("binaries"), new SimpleModelRuleDescriptor("binaries*.create()"), new Action<MutableModelNode>() { @Override public void execute(MutableModelNode modelNode) { modelNode.applyToAllLinks(ModelActionRole.Finalize, binaryTaskRule); } })); } catch (InvalidModelException e) { throw invalidModelRule(ruleDefinition, e); } }
@Override public Multimap<ModelActionRole, ModelAction> getActions( ModelReference<?> subject, ModelRuleDescriptor descriptor) { return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder() .put( ModelActionRole.Discover, DirectNodeInputUsingModelAction.of( subject, descriptor, Arrays.<ModelReference<?>>asList( ModelReference.of(ManagedProxyFactory.class), ModelReference.of(TypeConverter.class)), new BiAction<MutableModelNode, List<ModelView<?>>>() { @Override public void execute(MutableModelNode modelNode, List<ModelView<?>> modelViews) { ManagedProxyFactory proxyFactory = getInstance(modelViews.get(0), ManagedProxyFactory.class); TypeConverter typeConverter = getInstance(modelViews, 1, TypeConverter.class); for (StructSchema<?> viewSchema : bindings.getAllViewSchemas()) { addProjection(modelNode, viewSchema, proxyFactory, typeConverter); } } })) .put( ModelActionRole.Create, DirectNodeInputUsingModelAction.of( subject, descriptor, Arrays.<ModelReference<?>>asList( ModelReference.of(ModelSchemaStore.class), ModelReference.of(NodeInitializerRegistry.class)), new BiAction<MutableModelNode, List<ModelView<?>>>() { @Override public void execute(MutableModelNode modelNode, List<ModelView<?>> modelViews) { ModelSchemaStore schemaStore = getInstance(modelViews, 0, ModelSchemaStore.class); NodeInitializerRegistry nodeInitializerRegistry = getInstance(modelViews, 1, NodeInitializerRegistry.class); addPropertyLinks(modelNode, schemaStore, nodeInitializerRegistry); initializePrivateData(modelNode); } })) .build(); }
@Override protected List<ModelReference<?>> withImplicitInputs(List<? extends ModelReference<?>> inputs) { List<ModelReference<?>> allInputs = new ArrayList<ModelReference<?>>(inputs.size() + implicitInputs.size()); allInputs.addAll(inputs); for (ModelProperty<?> property : implicitInputs) { ManagedInstance value = (ManagedInstance) values.get(property.getName()); allInputs.add(ModelReference.of(value.getBackingNode().getPath())); } return allInputs; }
private <T> void registerAction( final ModelPath modelPath, final Class<T> viewType, final ModelRuleDescriptor descriptor, final ModelActionRole role, final Closure<?> closure) { final ModelReference<T> reference = ModelReference.of(modelPath, viewType); modelRegistry.configure( ModelActionRole.DefineRules, DirectNodeNoInputsModelAction.of( reference, descriptor, new Action<MutableModelNode>() { @Override public void execute(MutableModelNode mutableModelNode) { InputReferences inputs = inputPathsExtractor.transform(closure); List<String> absolutePaths = inputs.getAbsolutePaths(); List<Integer> absolutePathLineNumbers = inputs.getAbsolutePathLineNumbers(); final List<PotentialInput> potentialInputs = Lists.newArrayListWithCapacity(absolutePaths.size()); List<ModelReference<?>> actualInputs = Lists.newArrayListWithCapacity(potentialInputs.size()); for (int i = 0; i < absolutePaths.size(); i++) { String description = String.format("@ line %d", absolutePathLineNumbers.get(i)); String path = absolutePaths.get(i); potentialInputs.add(PotentialInput.absoluteInput(path, actualInputs.size())); actualInputs.add(ModelReference.untyped(ModelPath.path(path), description)); } mutableModelNode.applyToSelf( role, InputUsingModelAction.of( reference, descriptor, actualInputs, new BiAction<T, List<ModelView<?>>>() { @Override public void execute(final T t, List<ModelView<?>> modelViews) { ((TransformedClosure) closure) .applyRuleInputs(new PotentialInputs(modelViews, potentialInputs)); ClosureBackedAction.execute( t, closure.rehydrate( null, closure.getThisObject(), closure.getThisObject())); } })); } })); }
private void validateRuleMethod( MethodRuleDefinition<?, ?> ruleDefinition, Method ruleMethod, ValidationProblemCollector problems) { if (Modifier.isPrivate(ruleMethod.getModifiers())) { problems.add(ruleMethod, "A rule method cannot be private"); } if (Modifier.isAbstract(ruleMethod.getModifiers())) { problems.add(ruleMethod, "A rule method cannot be abstract"); } if (ruleMethod.getTypeParameters().length > 0) { problems.add(ruleMethod, "Cannot have type variables (i.e. cannot be a generic method)"); } // TODO validations on method: synthetic, bridge methods, varargs, abstract, native ModelType<?> returnType = ModelType.returnType(ruleMethod); if (returnType.isRawClassOfParameterizedType()) { problems.add( ruleMethod, "Raw type " + returnType + " used for return type (all type parameters must be specified of parameterized type)"); } for (int i = 0; i < ruleDefinition.getReferences().size(); i++) { ModelReference<?> reference = ruleDefinition.getReferences().get(i); if (reference.getType().isRawClassOfParameterizedType()) { problems.add( ruleMethod, "Raw type " + reference.getType() + " used for parameter " + (i + 1) + " (all type parameters must be specified of parameterized type)"); } if (reference.getPath() != null) { try { ModelPath.validatePath(reference.getPath().toString()); } catch (Exception e) { problems.add( ruleDefinition, "The declared model element path '" + reference.getPath() + "' used for parameter " + (i + 1) + " is not a valid path", e); } } } }
@Override public List<? extends ModelReference<?>> getInputs() { return Collections.singletonList(ModelReference.of(NodeInitializerRegistry.class)); }
protected List<SimulinkSignal> getSignals(String rootName) { List<SimulinkSignal> signals = new ArrayList<SimulinkSignal>(); // find all (top-level) connectors in the model or block Object[] foundConnectors = matlab.returningFeval( 1, find_system, rootName, SearchDepth, 1, FindAll, "on", LineType, SimulinkType.signal); if ((foundConnectors != null) && (foundConnectors.length == 1)) { // handles (ids) of the connectors double[] connHandles = (double[]) foundConnectors[0]; for (int i = 0; i < connHandles.length; i++) { double connHandle = connHandles[i]; double srcConnHandle = connHandle; double[] lineChildren = ((double[]) (matlab.returningFeval(1, get_param, connHandle, "LineChildren"))[0]); // Signals with children are not handled (directly). This is the case when a // block has more than one outgoing signal. if (lineChildren.length > 0) { continue; } double lineParent = ((double[]) (matlab.returningFeval(1, get_param, connHandle, "LineParent"))[0])[0]; // If lineParent has another value than -1.0 the source block has more than one outgoing // signal. // The id of the source block can now only be get by the root line parent... if (lineParent != -1.0) { // ...Started by the source block every signal fork creates line children for the current // signal. // These children can also have children of their own (if they have a fork). // So to get the source block we need to get the source block of the root line parent. double rootLineParent = lineParent; do { srcConnHandle = rootLineParent; rootLineParent = ((double[]) (matlab.returningFeval(1, get_param, rootLineParent, "LineParent"))[0]) [0]; } while (rootLineParent != -1.0); } String srcBlockName = (String) matlab.returningFeval(get_param, srcConnHandle, SrcBlock); String srcQualifiedBlockName = rootName + "/" + srcBlockName; String srcBlockType = (String) matlab.returningFeval(get_param, srcQualifiedBlockName, BlockType); String srcPortNumber = (String) matlab.returningFeval(get_param, srcConnHandle, SrcPort); String dstBlockName = (String) matlab.returningFeval(get_param, connHandle, DstBlock); String dstQualifiedBlockName = rootName + "/" + dstBlockName; String dstBlockType = (String) matlab.returningFeval(get_param, dstQualifiedBlockName, BlockType); String dstPortNumber = (String) matlab.returningFeval(get_param, connHandle, DstPort); SimulinkSignal signal = new SimulinkSignal( srcQualifiedBlockName, Integer.valueOf(srcPortNumber), dstQualifiedBlockName, Integer.valueOf(dstPortNumber), srcConnHandle); // ====== Handle Source ======= // if (srcBlockType.equals(SubSystem.toString())) { // src block is a sub system String srcPortName = getPortNameByNumber(srcQualifiedBlockName, srcPortNumber, false); signal.setSrcPortName(srcPortName); } else if (srcBlockType.equals(ModelReference.toString())) { // src block is a model reference String referencedModelName = (String) matlab.returningFeval(get_param, srcQualifiedBlockName, ModelName); matlab.loadModel(referencedModelName); String srcPortName = getPortNameByNumber(referencedModelName, srcPortNumber, false); signal.setSrcPortName(srcPortName); } // ====== Handle Destination ======= // if (dstBlockType.equals(SubSystem.toString())) { // dst block is a sub system String dstPortName = getPortNameByNumber(dstQualifiedBlockName, dstPortNumber, true); signal.setDstPortName(dstPortName); } else if (dstBlockType.equals(ModelReference.toString())) { // dst block is a model reference String referencedModelName = (String) matlab.returningFeval(get_param, dstQualifiedBlockName, ModelName); matlab.loadModel(referencedModelName); String dstPortName = getPortNameByNumber(referencedModelName, dstPortNumber, true); signal.setDstPortName(dstPortName); } signals.add(signal); } } return signals; }
public class DefaultNodeInitializerRegistry implements NodeInitializerRegistry { public static final ModelReference<NodeInitializerRegistry> DEFAULT_REFERENCE = ModelReference.of("nodeInitializerRegistry", NodeInitializerRegistry.class); private final LoadingCache<NodeInitializerContext<?>, NodeInitializer> cache = CacheBuilder.newBuilder() .weakValues() .build( new CacheLoader<NodeInitializerContext<?>, NodeInitializer>() { @Override public NodeInitializer load(NodeInitializerContext<?> context) throws Exception { return extractNodeInitializer(context); } }); private final List<NodeInitializerExtractionStrategy> allStrategies; private final List<NodeInitializerExtractionStrategy> additionalStrategies; private final ModelSchemaStore schemaStore; public DefaultNodeInitializerRegistry( ModelSchemaStore schemaStore, StructBindingsStore structBindingsStore) { this.schemaStore = schemaStore; this.allStrategies = Lists.newArrayList( new ModelSetNodeInitializerExtractionStrategy(), new SpecializedMapNodeInitializerExtractionStrategy(), new ModelMapNodeInitializerExtractionStrategy(), new ScalarCollectionNodeInitializerExtractionStrategy(), new ManagedImplStructNodeInitializerExtractionStrategy(structBindingsStore)); additionalStrategies = Lists.newArrayList(); } private ModelTypeInitializationException canNotConstructTypeException( NodeInitializerContext<?> context) { ImmutableSortedSet.Builder<ModelType<?>> constructibleTypes = ImmutableSortedSet.orderedBy(ModelTypes.displayOrder()); for (NodeInitializerExtractionStrategy extractor : additionalStrategies) { for (ModelType<?> constructibleType : extractor.supportedTypes()) { if (context.getConstraints().isSatisfiedBy(constructibleType)) { constructibleTypes.add(constructibleType); } } } return new ModelTypeInitializationException( context, schemaStore, ScalarTypes.TYPES, constructibleTypes.build()); } @Override public NodeInitializer getNodeInitializer(NodeInitializerContext<?> nodeInitializerContext) { try { return cache.get(nodeInitializerContext); } catch (ExecutionException e) { throw UncheckedException.throwAsUncheckedException(e); } catch (UncheckedExecutionException e) { throw UncheckedException.throwAsUncheckedException(e.getCause()); } } private <T> NodeInitializer extractNodeInitializer(NodeInitializerContext<T> context) { ModelSchema<T> schema = schemaStore.getSchema(context.getModelType()); for (NodeInitializerExtractionStrategy extractor : allStrategies) { NodeInitializer nodeInitializer = extractor.extractNodeInitializer(schema, context); if (nodeInitializer != null) { return nodeInitializer; } } throw canNotConstructTypeException(context); } @Override public void ensureHasInitializer(NodeInitializerContext<?> nodeInitializer) { getNodeInitializer(nodeInitializer); } @Override public void registerStrategy(NodeInitializerExtractionStrategy strategy) { allStrategies.add(0, strategy); additionalStrategies.add(0, strategy); } }
public BinaryTaskRule(Class<T> binaryType, MethodRuleDefinition<R, ?> ruleDefinition) { super(ModelReference.of(binaryType), binaryType, ruleDefinition); }