Java BasicModelExtent类代码示例

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private ModelExtent processSourcePair(String metamodel, String model) {
Resource mmRes =
    this.rs.getResource(URI.createFileURI(new File(metamodel).getAbsolutePath()), true);

EObject eObject = mmRes.getContents().get(0);
if (eObject instanceof EPackage) {
    EPackage p = (EPackage)eObject;
    // rs.getPackageRegistry().put(p.getNsURI(), p);
    EPackage.Registry.INSTANCE.put(p.getNsURI(), p);
}

Resource mRes =
    this.rs.getResource(URI.createFileURI(new File(model).getAbsolutePath()), true);

/* TODO: validate model against metamodel */

return new BasicModelExtent(mRes.getContents());
   }
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
@Override
protected ModelExtent[] arguments() {
    final ModelExtent psmContents = new BasicModelExtent(theSelectedResource.getContents());
    targetContents = new BasicModelExtent(Collections.<EObject> emptyList());
    targetFolder = theSelectedResource.getURI().trimFileExtension();
    final URI infrastructureTargetFolder = createURI(appendPath(targetFolder, getXmlSchemasFolder()).toString() + "/",
            true);

    final Collection<ModelExtent> modelExtents = new ArrayList<>(6);
    modelExtents.add(psmContents);
    for (final URI infrastructureSchemaLocation : org.search.niem.xsd.library.Activator.INSTANCE
            .getInfrastructureSchemaLocations()) {
        modelExtents.add(new BasicModelExtent(getInfrastructureResource(infrastructureSchemaLocation,
                infrastructureTargetFolder).getContents()));
    }
    modelExtents.add(targetContents);
    return modelExtents.toArray(new ModelExtent[modelExtents.size()]);
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private static ModelExtent createModelExtent(EObject rootElement) {
    BasicModelExtent modelExtent = new BasicModelExtent();
    if (rootElement != null) {
        modelExtent.add(rootElement);
    }
    return modelExtent;
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
@Override
protected final ModelExtent[] arguments() {
    final List<EObject> theCatalogContents = resourceSet.getResource(theSelectedResource.getURI(), true).getContents();
    thePIM = resourceSet.createResource(getThePimUri());
    System.out.println("thePimUri "+getThePimUri());
    final Model theRoot = UMLFactory.eINSTANCE.createModel();
    theRoot.setName("Data");
    // 
    final List<EObject> thePIMContents = thePIM.getContents();
    thePIMContents.add(theRoot);
    thePIMExtent = new BasicModelExtent(thePIMContents);
    return new ModelExtent[] { new BasicModelExtent(theCatalogContents), thePIMExtent };
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
@Override
protected ModelExtent[] arguments() {
    final ModelExtent psmContents = new BasicModelExtent(theSelectedResource.getContents());
    targetContents = new BasicModelExtent(Collections.<EObject> emptyList());
    targetFolder = theSelectedResource.getURI().trimFileExtension();
    
    // tjd add gra path to targetFolder
    // tjd TODO: need to support multiple IEPDs and name each one
    //  we could iterate at a higher level and adjust the targetFolder for each iteration
    //  but can not override the final transform of TransformDelegate, so would need to be outside the delegate pattern
    //  in any case, assume the qualifying PSM MPD Model is the name of the IEPD
    org.eclipse.uml2.uml.Package psmIepdModel=getPsmIepdModel();
    String iepdName="IEPD";
    if(psmIepdModel!=null)iepdName=psmIepdModel.getName();
    targetFolder = createURI(appendPath(targetFolder,"artifacts/service model/information model/"+iepdName).toString()+"/",true);
    
    final URI infrastructureTargetFolder = createURI(appendPath(targetFolder, getXmlSchemasFolder()).toString() + "/",
            true);

    final Collection<ModelExtent> modelExtents = new ArrayList<>(6);
    modelExtents.add(psmContents);
    for (final URI infrastructureSchemaLocation : org.ijis.gra.xsd.library.Activator.INSTANCE
            .getInfrastructureSchemaLocations()) {
        modelExtents.add(new BasicModelExtent(getInfrastructureResource(infrastructureSchemaLocation,
                infrastructureTargetFolder).getContents()));
    }
    modelExtents.add(targetContents);
    return modelExtents.toArray(new ModelExtent[modelExtents.size()]);
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
@Override
protected final ModelExtent[] arguments() {
	/*
    theTargetContents = new BasicModelExtent(Collections.<EObject> emptyList());
    final ModelExtent targetLocation = new BasicModelExtent(Collections.<EObject> emptyList());
    final List<ModelExtent> arguments = new ArrayList<>(asList(super.arguments()));
    arguments.add(arguments.size() - 1, targetLocation);
    arguments.add(theTargetContents);
    return arguments.toArray(new ModelExtent[arguments.size()]);
    */
    /*
     * in uml:UML,out cat:SPPCAT,out metadata:METADATA,out wsdl:WSDL
     */
    //targetFolder = theSelectedResource.getURI().trimFileExtension();
    targetFolder=GraUtility.getTargeDirectorytURI(theSelectedResource);
    final URI infrastructureTargetFolder = createURI(appendPath(targetFolder, getXmlSchemasFolder()).toString() + "/",
            true);
    
    ModelExtent psmContents = new BasicModelExtent(theSelectedResource.getContents());
    //catTarget = new BasicModelExtent(Collections.<EObject> emptyList());
    //metadataTarget = new BasicModelExtent(Collections.<EObject> emptyList());
    //wsdlTarget = new BasicModelExtent(Collections.<EObject> emptyList());
    annotationTarget = new BasicModelExtent(Collections.<EObject> emptyList());
    final Collection<ModelExtent> modelExtents = new ArrayList<>();
    modelExtents.add(psmContents);
    for (final URI infrastructureSchemaLocation : org.ijis.gra.xsd.library.Activator.INSTANCE
            .getInfrastructureSchemaLocations()) {
        modelExtents.add(new BasicModelExtent(getInfrastructureResource(infrastructureSchemaLocation,
                infrastructureTargetFolder).getContents()));
        break;
    }
    
    //modelExtents.add(catTarget);
    //modelExtents.add(metadataTarget);
    //modelExtents.add(wsdlTarget);// no longer
    modelExtents.add(annotationTarget);
    return modelExtents.toArray(new ModelExtent[modelExtents.size()]);
	
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
@Override
protected final ModelExtent[] arguments() {
    final List<EObject> theCatalogContents = resourceSet.getResource(theSelectedResource.getURI(), true).getContents();
    thePIM = resourceSet.createResource(getThePimUri());
    final Model theRoot = UMLFactory.eINSTANCE.createModel();
    theRoot.setName("Data");
    final List<EObject> thePIMContents = thePIM.getContents();
    thePIMContents.add(theRoot);
    thePIMExtent = new BasicModelExtent(thePIMContents);
    return new ModelExtent[] { new BasicModelExtent(theCatalogContents), thePIMExtent };
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private ModelExtent[] createInoutModelsExtentWithInitialContent(List<EObject>[] inoutModels) {
	ModelExtent[] inoutModelExtent = new ModelExtent[inoutModels.length];
	for (int i = 0; i < inoutModels.length; i++) {
		inoutModelExtent[i] = new BasicModelExtent();
		if (inoutModels[i] != null) {
			ArrayList<EObject> contents = new ArrayList<EObject>();
			contents.addAll(inoutModels[i]);
			inoutModelExtent[i].setContents(contents);
		}
	}
	return inoutModelExtent;
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private ModelExtent createModelExtent(String model) {
	Resource mRes = this.rs.getResource(URI.createFileURI(new File(model).getAbsolutePath()), true);

	return new BasicModelExtent(mRes.getContents());
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private void runIteration(String cim, String cosem, String substation, int index, String changeSet, String runIndex, String phase, TransformationExecutor executor, ExecutionContextImpl context) {

		List<ModelExtent> modelExtents = new ArrayList<ModelExtent>();
		long loadModelsstart = System.nanoTime();
		modelExtents.add(this.createModelExtent(cim));
		if ("outagePrevention".equals(this.transformation)) {
			modelExtents.add(this.createModelExtent(substation));
		}
		modelExtents.add(this.createModelExtent(cosem));
		long loadModelsEnd = System.nanoTime();
		if (phase == "Initial") {
			System.out.println("ModelJoin;" + this.transformation + ";" + changeSet + ";" + runIndex + ";" + Integer.toString(index) + ";" + phase + ";Time;" + Long.toString(loadModelsEnd-loadModelsstart));
		}
		ModelExtent output = new BasicModelExtent();
		modelExtents.add(output);
		modelExtents.add(new BasicModelExtent());

		long start = System.nanoTime();
		ExecutionDiagnostic result = executor.execute(context,
				modelExtents.toArray(new ModelExtent[modelExtents.size()]));
		long end = System.nanoTime();

		if (result.getSeverity() == Diagnostic.OK) {
			// the output objects got captured in the output extent
			XMIResource outResource = (XMIResource) rs
					.createResource(URI.createFileURI(new File(this.transformation + ".xmi").getAbsolutePath()));
			outResource.getContents().addAll(output.getContents());
			try {
				outResource.save(null);
				System.out.println("ModelJoin;" + this.transformation + ";" + changeSet + ";" + runIndex + ";" + Integer.toString(index) + ";" + phase + ";Time;" + Long.toString(end-start));
				System.out.println("ModelJoin;" + this.transformation + ";" + changeSet + ";" + runIndex + ";" + Integer.toString(index) + ";" + phase + ";Elements;" + Integer.toString(outResource.getContents().size()));
			} catch (IOException e) {
				e.printStackTrace();
			}
		} else {
			IStatus status = BasicDiagnostic.toIStatus(result);
			StringBuilder s = new StringBuilder();
			s.append("Failed to execute ");
			s.append(this.transformation);
			s.append(": ");
			s.append(status.getMessage());
			for (IStatus child : status.getChildren()) {
				s.append("\n " + child.getMessage());
			}
			System.err.println(s);
		}
	}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
public void build() {
      
this.rs.getResourceFactoryRegistry().
    getExtensionToFactoryMap().put("xmi", new XMIResourceFactoryImpl());

this.rs.getResourceFactoryRegistry().
    getExtensionToFactoryMap().put("ecore", new EcoreResourceFactoryImpl());

EPackage.Registry.INSTANCE.put(UMLPackage.eNS_URI, UMLPackage.eINSTANCE); 
Resource.Factory.Registry.INSTANCE.
    getExtensionToFactoryMap().put(UMLResource.FILE_EXTENSION, UMLResource.Factory.INSTANCE); 



List<ModelExtent> modelExtents = new ArrayList<ModelExtent>();

for(int i = 0; i < this.source.size(); i += 2) {
    modelExtents.add(this.processSourcePair(this.source.get(i),this.source.get(i+1)));
}

URI txURI = URI.createFileURI(new File(this.transformation).getAbsolutePath());
TransformationExecutor executor=new TransformationExecutor(txURI);

/* TODO: Does the CLI input match the QVTo transformation (xform) signature? 
   Use TransformationExecutor.loadTransformation() */ 

/* TODO: Put a scheme in place to support different file extensions and 
   use them to identify metamodels?! */




/* TODO: support multiple out parameters for xform */

ModelExtent output = new BasicModelExtent();
modelExtents.add(output);

ExecutionContextImpl context = new ExecutionContextImpl();
context.setConfigProperty("keepModeling", true);

OutputStreamWriter outStream = new OutputStreamWriter(System.out);
Log log = new WriterLog(outStream);
context.setLog(log);

ExecutionDiagnostic result = executor.execute(context,
					      modelExtents.toArray(new ModelExtent[modelExtents.size()]));

if(result.getSeverity() == Diagnostic.OK) {
    // the output objects got captured in the output extent
    UMLResource outResource = (UMLResource) rs.createResource(URI.createFileURI(new File("out.uml").getAbsolutePath()));
    outResource.getContents().addAll(output.getContents());
    try {
	outResource.save(null);
    } catch (IOException e) {
	e.printStackTrace();
    }
} else {
    IStatus status = BasicDiagnostic.toIStatus(result);
    StringBuilder s = new StringBuilder();
    s.append("Failed to execute ");
    s.append(txURI);
    s.append(": ");
    s.append(status.getMessage());
    for (IStatus child : status.getChildren()) {
	s.append("\n " + child.getMessage());
    }
    System.out.println(s);
}
   }
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
protected void testTraceTransformation(String modelName) throws Exception {
    // test parameters
    URI targetModelURI = createResourceModelURI(testPluginId, modelName + "." + targetFileExtension);
    URI umlModelURI = createResourceModelURI(testPluginId, modelName + ".uml");
    URI sourceModelURI = createResourceModelURI(testPluginId, modelName + "_tmp." + sourceFileExtension);

    /*
     * Run original transformation that yields
     * - the textual model
     * - the trace model to be compared (expected)
     */
    ModelExtent targetModel = createModelExtent(targetModelURI);
    ModelExtent umlModel = createModelExtent(umlModelURI);
    ModelExtent sourceModel = createModelExtent(sourceModelURI);
    Trace target2sourceTraceModel = new Trace(Collections.emptyList());
    runTransformation(targetToSourceTransformationUri, targetModel, umlModel, sourceModel, target2sourceTraceModel);

    /*
     * Run text to graphics transformation that yields
     * - the second graphical model
     * - the t2g trace model (input for trace transformation)
     */
    ModelExtent targetModel2 = new BasicModelExtent();
    Trace source2targetTrace = new Trace(Collections.emptyList());
    runTransformation(sourceToTargetTransformationUri, sourceModel, umlModel, targetModel2, source2targetTrace);

    /*
     * Transform trace model to point to elements of graphicalModel instead of graphicalModel2
     */
    repairTransformationTrace(targetModel, targetModel2, source2targetTrace);

    /*
     * Run trace transformation that yields
     * - the actual trace model to be compared (actual)
     */
    ModelExtent sourceToTargetTraceModel = new BasicModelExtent(source2targetTrace.getTraceContent());
    ModelExtent actualTraceModel = new BasicModelExtent();
    ModelExtent target2sourceTransformationModel = new BasicModelExtent(
            new QVTOResource(targetToSourceTransformationUri, getResourceSet().getPackageRegistry()).getContents());
    runTransformation(sourceToTargetTraceTransformationUri, Arrays.asList(sourceToTargetTraceModel,
            actualTraceModel, targetModel, target2sourceTransformationModel), new Trace(Collections.emptyList()));

    // compare expected and actual
    assertTraceEquals(target2sourceTraceModel, actualTraceModel);
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
protected ModelExtent runTransformation(URI transformationURI, URI sourceModelURI, URI umlModelURI)
        throws IOException {
    return runTransformation(transformationURI, sourceModelURI, umlModelURI, new BasicModelExtent(),
            new Trace(Collections.emptyList()));
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private static ModelExtent createModelExtent(Resource r) {
    return new BasicModelExtent(r.getContents());
}
 

import org.eclipse.m2m.qvt.oml.BasicModelExtent; //导入依赖的package包/类
private static void transform (OperationInterfaceContainer opInterfaceContainer, List<EObject> external, IOverviewConverterCallback callback)
{
			final Overview overviewModel = (Overview)EcoreUtil.getRootContainer(opInterfaceContainer);

               URI transformationURI = URI.createURI("platform:/plugin/eu.cloudscaleproject.env.csm2pcm/transforms/pcm2opInterfaceContainer.qvto");
               final TransformationExecutor executor = new TransformationExecutor(transformationURI);
               executor.loadTransformation();

               final ExecutionContextImpl context = new ExecutionContextImpl();

               
               context.setLog(new TransformationLogger());
               context.setConfigProperty("moduleID", opInterfaceContainer.getId());
               context.setConfigProperty("CSMID", CSM_ID_PREFIX);
               
               context.setConfigProperty("PCM_REPOSITORY_KEY", IOverviewConverter.KEY_PCM_REPOSITORY);
               context.setConfigProperty("PCM_SYSTEM_KEY", IOverviewConverter.KEY_PCM_SYSTEM);
               context.setConfigProperty("PCM_INTERFACE_KEY", IOverviewConverter.KEY_PCM_INTERFACE);
               context.setConfigProperty("PCM_OPERATION_KEY", IOverviewConverter.KEY_PCM_OPERATION);

			//clear interfaces
			OverviewArchitectureUtil.deleteInterfaces(opInterfaceContainer.getProvidedInterfaces());
			OverviewArchitectureUtil.deleteInterfaces(opInterfaceContainer.getRequiredInterfaces());

			List<EObject> inputCsmList = new ArrayList<EObject>();
			inputCsmList.add(overviewModel);
			
			ResourceSet dataSet = new ResourceSetImpl();
			
			//find resource set
			for(EObject eo : external){
				if(eo instanceof Repository){
					
					EcoreUtil.resolveAll(eo);
					
					if(eo.eResource() != null && eo.eResource().getResourceSet() != null){
						dataSet = eo.eResource().getResourceSet();
					}
				}
			}
			
			URI inDataTypeUri = URI.createURI("pathmap://PCM_MODELS/PrimitiveTypes.repository");
			Resource dataTypesResource = dataSet.getResource(inDataTypeUri, true);
			EList<EObject> inObjectsDataTypes = dataTypesResource.getContents();
			
			final ModelExtent inputCsm = new BasicModelExtent(inputCsmList);
			final ModelExtent inputExternal = new BasicModelExtent(external);
			final ModelExtent inputDataTypes = new BasicModelExtent(inObjectsDataTypes);
			
			ExecutionDiagnostic result = executor.execute(context, inputExternal, inputDataTypes, inputCsm);

			if(result.getSeverity() == Diagnostic.OK) {
				try {
					if (overviewModel.eResource() != null)
						overviewModel.eResource().save(null);
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				if(callback != null){
					callback.callback();
				}
			}
			else{
				// turn the result diagnostic into status and send it to error log			
				IStatus status = BasicDiagnostic.toIStatus(result);
				Activator.getDefault().getLog().log(status);
			}
}