Java ECollections.newBasicEList方法代码示例

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated NOT
 */
@Override
public EList<InputSpecification> getKnownInputs ()
{
    if ( this.knownInputs == null )
    {
        final BasicEList<InputSpecification> inputs = ECollections.newBasicEList ();
        inputs.add ( Components.createInput ( "input" ) );
        this.knownInputs = ECollections.unmodifiableEList ( inputs );
    }
    return this.knownInputs;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated NOT
 */
@Override
public EList<OutputSpecification> getKnownOutputs ()
{
    if ( this.knownOutputs == null )
    {
        final BasicEList<OutputSpecification> outputs = ECollections.newBasicEList ();
        for ( final AverageReferenceType type : AverageReferenceType.values () )
        {
            outputs.add ( Components.createOutput ( type.getLiteral (), DataType.FLOAT ) );
        }
        this.knownOutputs = ECollections.unmodifiableEList ( outputs );
    }
    return this.knownOutputs;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated NOT
 */
@Override
public EList<OutputSpecification> getKnownOutputs ()
{
    if ( this.knownOutputs == null )
    {
        final BasicEList<OutputSpecification> outputs = ECollections.newBasicEList ();
        outputs.add ( Components.createOutput ( "output", null ) );
        this.knownOutputs = ECollections.unmodifiableEList ( outputs );
    }
    return this.knownOutputs;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 *
 * @generated NOT
 */
@Override
public EList<InputSpecification> getKnownInputs ()
{
    if ( this.knownInputs == null )
    {
        final BasicEList<InputSpecification> inputs = ECollections.newBasicEList ();
        inputs.add ( Components.createInput ( "input" ) );
        this.knownInputs = ECollections.unmodifiableEList ( inputs );
    }
    return this.knownInputs;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 *
 * @generated NOT
 */
@Override
public EList<OutputSpecification> getKnownOutputs ()
{
    if ( this.knownOutputs == null )
    {
        final BasicEList<OutputSpecification> outputs = ECollections.newBasicEList ();
        for ( final MovingAverageReferenceType type : MovingAverageReferenceType.values () )
        {
            outputs.add ( Components.createOutput ( type.getLiteral (), DataType.FLOAT ) );
        }
        this.knownOutputs = ECollections.unmodifiableEList ( outputs );
    }
    return this.knownOutputs;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated NOT
 */
@Override
public EList<Endpoint> getEndpoints ()
{
    final EList<Endpoint> result = ECollections.newBasicEList ();
    for ( final Exporter exporter : getExporter () )
    {
        result.addAll ( exporter.getEndpoints () );
    }
    return result;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 *
 * @generated NOT
 */
@Override
public EList<Endpoint> getEndpoints ()
{
    final EList<Endpoint> result = ECollections.newBasicEList ();
    for ( final Exporter exporter : getExporter () )
    {
        result.addAll ( exporter.getEndpoints () );
    }
    return result;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated NOT
 */
public EList<EPackage> getEPackages() {
	EList<EPackage> ret = ECollections.newBasicEList();
	for (EPackageSource ps: getPackageSources()) {
		ret.addAll(ps.getEPackages(resourceSet));
	}		
	return ret;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
@Override
public IScope getScope(final EObject context, final EReference reference) {
  if (reference == CheckcfgPackage.Literals.CONFIGURED_CHECK__CHECK) {
    // Note that context object can be either a configured check (if 'optional' keyword has been provided
    // so that a new instance is created and the configured catalog does not contain any configured checks
    // yet) or a configured catalog (in all other cases)
    final ConfiguredCatalog configuredCatalog = EcoreUtil2.getContainerOfType(context, ConfiguredCatalog.class);
    if (configuredCatalog == null || configuredCatalog.getCatalog() == null) {
      return IScope.NULLSCOPE;
    }
    CheckCatalog catalog = configuredCatalog.getCatalog();
    return Scopes.scopeFor(catalog.getAllChecks(), checkQualifiedNameProvider, IScope.NULLSCOPE);
  } else if (reference == CheckcfgPackage.Literals.CONFIGURED_PARAMETER__PARAMETER) {
    // a new list of FormalParameters to scope to
    EList<FormalParameter> parameters = ECollections.newBasicEList();
    final ConfiguredCheck configuredCheck = EcoreUtil2.getContainerOfType(context, ConfiguredCheck.class);
    if (configuredCheck != null) {
      // add FormalParameter definitions from linked check
      parameters.addAll(configuredCheck.getCheck().getFormalParameters());
    }
    // add inferred FormalParameters (properties)
    final CheckConfiguration checkConfiguration = EcoreUtil2.getContainerOfType(context, CheckConfiguration.class);
    parameters.addAll(checkConfiguration.getProperties());
    return Scopes.scopeFor(parameters, checkQualifiedNameProvider, IScope.NULLSCOPE);
  }
  return super.getScope(context, reference);
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated NOT
 */
public EList<EPackage> getEPackages(ResourceSet resourceSet) {
	EList<EPackage> ret = ECollections.newBasicEList();
	
	if (getLocation() == null || getLocation().trim().length() == 0) {
		// Global registry
		for (String nsURI: getNsURIs()) {
			EPackage ep = EPackage.Registry.INSTANCE.getEPackage(nsURI);
			if (ep != null) {
				ret.add(ep);
			}
		}			
	} else {
		URI uri = URI.createURI(getLocation());
		if (uri.isRelative()) {
			if (eResource() == null) {
				System.err.println("Resource is null"); // TODO - proper logging.
				return ret;
			}
			
			URI base = eResource().getURI();
			if (base != null && base.isHierarchical()) {
				uri = uri.resolve(base);
			}
		}
		Resource resource = resourceSet.getResource(uri, true);
		TreeIterator<EObject> cit = resource.getAllContents();
		while (cit.hasNext()) {
			EObject next = cit.next();
			if (next instanceof EPackage) {
				if ((getNsURIs().isEmpty() || getNsURIs().contains(((EPackage) next).getNsURI()))) {
					ret.add((EPackage) next);
				}
			} else if (next instanceof GenPackage) {
				GenPackage genPackage = (GenPackage) next;
				EPackage ePackage = genPackage.getEcorePackage();	
				if ((getNsURIs().isEmpty() || getNsURIs().contains(ePackage.getNsURI()))) {
					ret.add(ePackage);
					for (GenClassifier gc: genPackage.getGenClassifiers()) {
						EClassifier ec = gc.getEcoreClassifier();
						if (ec.getInstanceClassName() == null) {
							ec.setInstanceClassName(gc.getRawInstanceClassName());
						}
					}
				}
			}
		}
	}

	return ret;
}
 

import org.eclipse.emf.common.util.ECollections; //导入方法依赖的package包/类
@Override
public java.util.Map<String, Model> run(
		java.util.Map<String, Model> inputsByName, java.util.Map<String, GenericElement> genericsByName,
		java.util.Map<String, MID> outputMIDsByName) throws Exception {

	// input
	List<Model> inputMIDModels = MIDOperatorIOUtils.getVarargs(inputsByName, IN_MIDS);
	EList<MID> inputMIDs = ECollections.newBasicEList();
	EList<Set<Model>> modelBlacklists = ECollections.newBasicEList();
	for (Model inputMIDModel : inputMIDModels) {
		inputMIDs.add((MID) inputMIDModel.getEMFInstanceRoot());
		modelBlacklists.add(new HashSet<>());
	}
	Operator mapperOperatorType = (Operator) genericsByName.get(GENERIC_OPERATORTYPE);
	java.util.Map<String, MID> instanceMIDsByMapperOutput = MIDOperatorIOUtils.getVarargOutputMIDsByOtherName(outputMIDsByName, OUT_MIDS, mapperOperatorType.getOutputs());

	// find all possible combinations of inputs and execute them
	java.util.Map<Operator, Set<EList<OperatorInput>>> mapperSpecs = new LinkedHashMap<>(); // reproducible order
	EList<Operator> polyOperators = (Boolean.parseBoolean(MMINT.getPreference(MMINTConstants.PREFERENCE_MENU_POLYMORPHISM_MULTIPLEDISPATCH_ENABLED))) ?
		ECollections.asEList(MIDTypeHierarchy.getSubtypes(mapperOperatorType)) :
		ECollections.emptyEList();
	if (polyOperators.isEmpty()) { // multiple dispatch disabled, or the mapper operator is not a multimethod
		mapperSpecs.put(mapperOperatorType, mapperOperatorType.findAllowedInputs(inputMIDs, modelBlacklists));
	}
	else {
		polyOperators.add(mapperOperatorType);
		java.util.Map<String, EList<OperatorInput>> assignedInputs = new HashMap<>();
		Iterator<Operator> polyIter = MIDTypeHierarchy.getInverseTypeHierarchyIterator(polyOperators);
		while (polyIter.hasNext()) { // start from the most specialized operator backwards
			Operator polyMapper = polyIter.next();
			// assign at each step the allowed inputs that have not been already assigned
			Set<EList<OperatorInput>> mapperInputs = polyMapper.findAllowedInputs(inputMIDs, modelBlacklists);
			java.util.Map<String, EList<OperatorInput>> newInputs = this.diffMultipleDispatchInputs(assignedInputs, mapperInputs);
			mapperSpecs.put(polyMapper, new LinkedHashSet<>(newInputs.values())); // reproducible order
			assignedInputs.putAll(newInputs);
		}
	}
	java.util.Map<String, Model> outputsByName = this.map(inputMIDModels, inputMIDs, mapperOperatorType, mapperSpecs, instanceMIDsByMapperOutput);

	return outputsByName;
}