org.eclipse.xtext.common.types.TypesFactory Java Examples

public MutableConstructorDeclaration addConstructor(final Procedure1<MutableConstructorDeclaration> initializer) {
  this.checkMutable();
  Preconditions.checkArgument((initializer != null), "initializer cannot be null");
  final Function1<JvmConstructor, Boolean> _function = (JvmConstructor it) -> {
    return Boolean.valueOf(this.getCompilationUnit().getTypeExtensions().isSingleSyntheticDefaultConstructor(it));
  };
  final JvmConstructor constructor = IterableExtensions.<JvmConstructor>findFirst(Iterables.<JvmConstructor>filter(this.getDelegate().getMembers(), JvmConstructor.class), _function);
  if ((constructor != null)) {
    EcoreUtil.remove(constructor);
  }
  final JvmConstructor newConstructor = TypesFactory.eINSTANCE.createJvmConstructor();
  newConstructor.setVisibility(JvmVisibility.PUBLIC);
  newConstructor.setSimpleName(this.getSimpleName());
  this.getDelegate().getMembers().add(newConstructor);
  MemberDeclaration _memberDeclaration = this.getCompilationUnit().toMemberDeclaration(newConstructor);
  final MutableConstructorDeclaration mutableConstructorDeclaration = ((MutableConstructorDeclaration) _memberDeclaration);
  initializer.apply(mutableConstructorDeclaration);
  return mutableConstructorDeclaration;
}
 

/**
 * {@inheritDoc}
 * 
 * Returns the value of the 'Type' reference. If there is no type set, 
 * a reference to <code>java.lang.Object</code> is assumed as soon as there is more 
 * than one contained reference.
 * If there is only one contained reference, its type is returned.
 */
@Override
public JvmType getType() {
	if (references != null && !references.isEmpty()) {
		if (references.size() == 1) {
			return references.get(0).getType();
		}
		if (type == null) {
			JvmGenericType objectType = TypesFactory.eINSTANCE.createJvmGenericType();
			String objectClassName = Object.class.getName();
			((InternalEObject) objectType).eSetProxyURI(URIHelperConstants.OBJECTS_URI.appendSegment(objectClassName).appendFragment(objectClassName));
			type = objectType;
		}
	}
	return super.getType();
}
 

/**
 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
 * that can be created under this object.
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object)
{
	super.collectNewChildDescriptors(newChildDescriptors, object);

	newChildDescriptors.add
		(createChildParameter
			(TypesPackage.Literals.JVM_CONSTRAINT_OWNER__CONSTRAINTS,
			 TypesFactory.eINSTANCE.createJvmUpperBound()));

	newChildDescriptors.add
		(createChildParameter
			(TypesPackage.Literals.JVM_CONSTRAINT_OWNER__CONSTRAINTS,
			 TypesFactory.eINSTANCE.createJvmLowerBound()));
}
 

@Override
public MutableTypeParameterDeclaration addTypeParameter(final String name, final TypeReference... upperBounds) {
  this.checkMutable();
  ConditionUtils.checkJavaIdentifier(name, "name");
  ConditionUtils.checkIterable(((Iterable<?>)Conversions.doWrapArray(upperBounds)), "upperBounds");
  ConditionUtils.checkInferredTypeReferences("parameter type", upperBounds);
  final JvmTypeParameter param = TypesFactory.eINSTANCE.createJvmTypeParameter();
  param.setName(name);
  this.getDelegate().getTypeParameters().add(param);
  for (final TypeReference upper : upperBounds) {
    {
      final JvmTypeReference typeRef = this.getCompilationUnit().toJvmTypeReference(upper);
      final JvmUpperBound jvmUpperBound = TypesFactory.eINSTANCE.createJvmUpperBound();
      jvmUpperBound.setTypeReference(typeRef);
      param.getConstraints().add(jvmUpperBound);
    }
  }
  TypeParameterDeclaration _typeParameterDeclaration = this.getCompilationUnit().toTypeParameterDeclaration(param);
  return ((MutableTypeParameterDeclaration) _typeParameterDeclaration);
}
 

private JvmAnnotationValue createBooleanAnnotationValue(Object value) {
	JvmBooleanAnnotationValue annotationValue = TypesFactory.eINSTANCE.createJvmBooleanAnnotationValue();
	if (value != null) {
		@SuppressWarnings("unchecked")
		InternalEList<Object> values = (InternalEList<Object>)(InternalEList<?>)annotationValue.getValues();
		if (value instanceof Object[]) {
			for (Object element : (Object[])value) {
				if (element instanceof Boolean) {
					values.addUnique(element);
				}
			}
		} else {
			values.addUnique(value);
		}
	}
	return annotationValue;
}
 

private JvmAnnotationValue createShortAnnotationValue(Object value) {
	JvmShortAnnotationValue annotationValue = TypesFactory.eINSTANCE.createJvmShortAnnotationValue();
	if (value != null) {
		@SuppressWarnings("unchecked")
		InternalEList<Object> values = (InternalEList<Object>)(InternalEList<?>)annotationValue.getValues();
		if (value instanceof Object[]) {
			for (Object element : (Object[])value) {
				if (element instanceof Short) {
					values.addUnique(element);
				} else if (element != null) {
					values.addUnique(((Number)element).shortValue());
				}
			}
		} else if (value instanceof Short) {
			values.addUnique(value);
		} else if (value instanceof Number) {
			values.addUnique(((Number)value).shortValue());
		}
	}
	return annotationValue;
}
 

protected void completeJvmGenericType(JvmGenericType element) {
	// if no super type add Object
	ensureSuperTypeObject(element);
	addAnnotations(element);
	if (!element.isInterface()) {
		// if no constructors have been added, add a default constructor
		if (isEmpty(element.getDeclaredConstructors())) {
			JvmConstructor constructor = TypesFactory.eINSTANCE.createJvmConstructor();
			constructor.setSimpleName(element.getSimpleName());
			constructor.setVisibility(JvmVisibility.PUBLIC);
			typeExtensions.setSynthetic(constructor, true);
			EObject primarySourceElement = associations.getPrimarySourceElement(element);
			if (primarySourceElement != null) {
				associator.associate(primarySourceElement, constructor);
			}
			element.getMembers().add(constructor);
		}
	}
}
 

/**
 * @since 2.4
 */
protected JvmOperation createOperation(StringBuilder qualifiedName, String handleIdentifier, String[] path, IMethodBinding method) {
	JvmOperation result = TypesFactory.eINSTANCE.createJvmOperation();
	enhanceGenericDeclaration(result, method.getTypeParameters());
	enhanceExecutable(qualifiedName, handleIdentifier, path, result, method);
	int modifiers = method.getModifiers();
	result.setAbstract(Modifier.isAbstract(modifiers));
	result.setFinal(Modifier.isFinal(modifiers));
	result.setStatic(Modifier.isStatic(modifiers));
	result.setStrictFloatingPoint(Modifier.isStrictfp(modifiers));
	result.setSynchronized(Modifier.isSynchronized(modifiers));
	result.setNative(Modifier.isNative(modifiers));
	result.setReturnType(createTypeReference(method.getReturnType()));
	createAnnotationValues(method, result);
	return result;
}
 

protected JvmTypeReference getJavaLangObjectTypeRef(JvmType rawType, TypesFactory typesFactory) {
	ResourceSet rs = EcoreUtil2.getResourceSet(rawType);
	JvmParameterizedTypeReference refToObject = typesFactory.createJvmParameterizedTypeReference();
	if (rs != null) {
		EObject javaLangObject = rs.getEObject(javaLangObjectURI, true);
		if (javaLangObject instanceof JvmType) {
			JvmType objectDeclaration = (JvmType) javaLangObject;
			refToObject.setType(objectDeclaration);
			return refToObject;
		}
	}
	JvmGenericType proxy = typesFactory.createJvmGenericType();
	((InternalEObject)proxy).eSetProxyURI(javaLangObjectURI);
	refToObject.setType(proxy);
	return refToObject;
}
 

protected JvmEnumerationType createEnumerationType(Class<?> clazz) {
	JvmEnumerationType result = TypesFactory.eINSTANCE.createJvmEnumerationType();
	result.internalSetIdentifier(clazz.getName());
	result.setSimpleName(clazz.getSimpleName());
	if (clazz.getDeclaringClass() == null && clazz.getPackage() != null)
		result.setPackageName(clazz.getPackage().getName());
	setVisibility(clazz, result);
	setTypeModifiers(clazz, result);
	createNestedTypes(clazz, result);
	createMethods(clazz, result);
	createFields(clazz, result);
	createConstructors(clazz, result);
	setSuperTypes(clazz, result);
	createAnnotationValues(clazz, result);
	return result;
}
 

protected JvmTypeReference toTypeReference(final JvmType type, final int arrayDimensions) {
  if ((type == null)) {
    return null;
  }
  JvmParameterizedTypeReference _createJvmParameterizedTypeReference = TypesFactory.eINSTANCE.createJvmParameterizedTypeReference();
  final Procedure1<JvmParameterizedTypeReference> _function = (JvmParameterizedTypeReference it) -> {
    it.setType(type);
  };
  JvmTypeReference resultTypeRef = ObjectExtensions.<JvmParameterizedTypeReference>operator_doubleArrow(_createJvmParameterizedTypeReference, _function);
  ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, arrayDimensions, true);
  for (final Integer i : _doubleDotLessThan) {
    {
      final JvmGenericArrayTypeReference arrayRef = TypesFactory.eINSTANCE.createJvmGenericArrayTypeReference();
      arrayRef.setComponentType(resultTypeRef);
      resultTypeRef = arrayRef;
    }
  }
  return resultTypeRef;
}
 

private JvmAnnotationValue createIntAnnotationValue(Object value) {
	JvmIntAnnotationValue annotationValue = TypesFactory.eINSTANCE.createJvmIntAnnotationValue();
	if (value != null) {
		@SuppressWarnings("unchecked")
		InternalEList<Object> values = (InternalEList<Object>)(InternalEList<?>)annotationValue.getValues();
		if (value instanceof Object[]) {
			for (Object element : (Object[])value) {
				if (element instanceof Integer) {
					values.addUnique(element);
				} else if (element != null) {
					values.addUnique(((Number)element).intValue());
				}
			}
		} else if (value instanceof Integer) {
			values.addUnique(value);
		} else if (value instanceof Number) {
			values.addUnique(((Number)value).intValue());
		}
	}
	return annotationValue;
}
 

private JvmAnnotationValue createStringAnnotationValue(Object value) {
	JvmStringAnnotationValue annotationValue = TypesFactory.eINSTANCE.createJvmStringAnnotationValue();
	if (value != null) {
		@SuppressWarnings("unchecked")
		InternalEList<Object> values = (InternalEList<Object>)(InternalEList<?>)annotationValue.getValues();
		if (value instanceof Object[]) {
			for (Object element : (Object[])value) {
				if (element instanceof String) {
					values.addUnique(element);
				}
			}
		} else {
			values.addUnique(value);
		}
	}
	return annotationValue;
}
 

protected JvmType createProxy(ITypeBinding typeBinding) {
	JvmType proxy = typeProxies.get(typeBinding);
	if (proxy == null) {
		if (typeBinding.isPrimitive()) {
			proxy = PRIMITIVE_PROXIES[typeBinding.getKey().charAt(0) - 'B'];
		} else {
			URI uri = uriHelper.getFullURI(typeBinding);
			proxy = COMMON_PROXIES.get(uri.fragment());
			if (proxy == null) {
				proxy = TypesFactory.eINSTANCE.createJvmVoid();
				((InternalEObject)proxy).eSetProxyURI(uri);
			}
		}
		typeProxies.put(typeBinding, proxy);
	}
	return proxy;
}
 

public JvmType createProxy(BinaryTypeSignature type, Map<String, JvmTypeParameter> typeParameters) {
	String variableName = type.getTypeVariableName();
	if (variableName != null) {
		if (typeParameters == null) {
			throw new IllegalStateException(type.toString());
		}
		JvmType result = typeParameters.get(variableName);
		if (result == null) {
			throw new IllegalStateException(type.toString());
		}
		return result;
	}
	JvmType proxy = typeProxies.get(type);
	if (proxy == null) {
		proxy = TypesFactory.eINSTANCE.createJvmVoid();
		URI uri = type.getURI();
		((InternalEObject) proxy).eSetProxyURI(uri);
		typeProxies.put(type, proxy);
	}
	return proxy;
}
 

public MutableTypeParameterDeclaration addTypeParameter(final String name, final TypeReference... upperBounds) {
  this.checkMutable();
  ConditionUtils.checkJavaIdentifier(name, "name");
  ConditionUtils.checkIterable(((Iterable<?>)Conversions.doWrapArray(upperBounds)), "upperBounds");
  ConditionUtils.checkInferredTypeReferences("parameter type", upperBounds);
  final JvmTypeParameter param = TypesFactory.eINSTANCE.createJvmTypeParameter();
  param.setName(name);
  this.getDelegate().getTypeParameters().add(param);
  for (final TypeReference upper : upperBounds) {
    {
      final JvmTypeReference typeRef = this.getCompilationUnit().toJvmTypeReference(upper);
      final JvmUpperBound jvmUpperBound = TypesFactory.eINSTANCE.createJvmUpperBound();
      jvmUpperBound.setTypeReference(typeRef);
      param.getConstraints().add(jvmUpperBound);
    }
  }
  TypeParameterDeclaration _typeParameterDeclaration = this.getCompilationUnit().toTypeParameterDeclaration(param);
  return ((MutableTypeParameterDeclaration) _typeParameterDeclaration);
}
 

private List<JvmTypeParameter> cloneTypeParameters(JvmOperation fromOperation, JvmDeclaredType declaringType) {
	final SARLQuickfixProvider tools = getTools();
	final JvmTypeReferenceBuilder builder1 = tools.getJvmTypeParameterBuilder();
	final JvmTypesBuilder builder2 = tools.getJvmTypeBuilder();
	final TypeReferences builder3 = tools.getTypeServices().getTypeReferences();
	final TypesFactory builder4 = tools.getTypeServices().getTypesFactory();
	final List<JvmTypeParameter> outParameters = new ArrayList<>();
	// Get the type parameter mapping that is a consequence of the super type extension within the container.
	final Map<String, JvmTypeReference> superTypeParameterMapping = new HashMap<>();
	Utils.getSuperTypeParameterMap(declaringType, superTypeParameterMapping);
	Utils.copyTypeParametersFromJvmOperation(
			fromOperation.getTypeParameters(),
			outParameters,
			superTypeParameterMapping,
			builder1, builder2, builder3, builder4);
	return outParameters;
}
 

private JvmAnnotationValue createAnnotationAnnotationValue(Object value) {
	JvmAnnotationAnnotationValue annotationValue = TypesFactory.eINSTANCE.createJvmAnnotationAnnotationValue();
	if (value != null) {
		InternalEList<JvmAnnotationReference> values = (InternalEList<JvmAnnotationReference>)annotationValue.getValues();
		if (value instanceof Object[]) {
			for (Object element : (Object[])value) {
				if (element instanceof IAnnotationBinding) {
					values.addUnique(createAnnotationReference((IAnnotationBinding)element));
				}
			}
		} else if (value instanceof IAnnotationBinding) {
			values.addUnique(createAnnotationReference((IAnnotationBinding)value));
		}
	}
	return annotationValue;
}
 

/**
 * This adds {@link org.eclipse.emf.edit.command.CommandParameter}s describing the children
 * that can be created under this object.
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
protected void collectNewChildDescriptors(Collection<Object> newChildDescriptors, Object object)
{
	super.collectNewChildDescriptors(newChildDescriptors, object);

	newChildDescriptors.add
		(createChildParameter
			(TypesPackage.Literals.JVM_CONSTRAINT_OWNER__CONSTRAINTS,
			 TypesFactory.eINSTANCE.createJvmUpperBound()));

	newChildDescriptors.add
		(createChildParameter
			(TypesPackage.Literals.JVM_CONSTRAINT_OWNER__CONSTRAINTS,
			 TypesFactory.eINSTANCE.createJvmLowerBound()));
}
 

@Override
public JvmArrayType getArrayType() {
	JvmArrayType result = super.getArrayType();
	if (result == null) {
		result = TypesFactory.eINSTANCE.createJvmArrayType();
		boolean wasDeliver = eDeliver();
		eSetDeliver(false);
		try {
			setArrayType(result);
		} finally {
			eSetDeliver(wasDeliver);
		}
	}
	return result;
}
 

protected JvmType createProxy(Type type) {
	JvmType proxy = typeProxies.get(type);
	if (proxy == null) {
		proxy = TypesFactory.eINSTANCE.createJvmVoid();
		URI uri = uriHelper.getFullURI(type);
		((InternalEObject)proxy).eSetProxyURI(uri);
		typeProxies.put(type, proxy);
	}
	return proxy;
}
 

@Test
public void testInterfaceDescription_01() {
	JvmGenericType interfaceType = TypesFactory.eINSTANCE.createJvmGenericType();
	interfaceType.setInterface(true);
	interfaceType.setPackageName("foo");
	interfaceType.setSimpleName("MyType");
	List<IEObjectDescription> list = new ArrayList<>();
	descriptionStrategy.createEObjectDescriptions(interfaceType, it -> list.add(it));
	Assert.assertTrue(
			list.stream().anyMatch(it -> "true".equals(it.getUserData(JvmTypesResourceDescriptionStrategy.IS_INTERFACE))));
}
 

protected JvmTypeParameter createTypeParameter(TypeVariable<?> variable, JvmMember container) {
	JvmTypeParameter result = TypesFactory.eINSTANCE.createJvmTypeParameter();
	result.setName(variable.getName());
	Type[] bounds = variable.getBounds();
	if (bounds.length != 0) {
		InternalEList<JvmTypeConstraint> constraints = (InternalEList<JvmTypeConstraint>)result.getConstraints();
		for (Type bound : variable.getBounds()) {
			JvmUpperBound upperBound = TypesFactory.eINSTANCE.createJvmUpperBound();
			((JvmTypeConstraintImplCustom) upperBound).internalSetTypeReference(createTypeReference(bound));
			constraints.addUnique(upperBound);
		}
	}
	return result;
}
 

@Override
public void visitEnum(final String name, final String desc, final String value) {
	JvmEnumAnnotationValue result = TypesFactory.eINSTANCE.createJvmEnumAnnotationValue();
	JvmEnumerationLiteral enumLiteralProxy = proxies.createEnumLiteral(value, desc);
	((InternalEList<JvmEnumerationLiteral>) result.getValues()).addUnique(enumLiteralProxy);
	result.setOperation(proxies.createMethodProxy(annotationType, name));
	values.addUnique(result);
}
 

public JvmAnnotationReferenceBuilder(InternalEList<JvmAnnotationReference> target, String desc, Proxies proxies) {
	super(Opcodes.ASM8);
	this.proxies = proxies;
	this.target = target;
	this.annotationType = BinarySignatures.createTypeSignature(desc);
	result = TypesFactory.eINSTANCE.createJvmAnnotationReference();
	result.setAnnotation(proxies.createAnnotationProxy(annotationType));
	values = (InternalEList<JvmAnnotationValue>) result.getExplicitValues();
}
 

@Override
public void visitEnum(String name, String desc, String value) {
	if (name != null) {
		throw new IllegalStateException();
	}
	if (result == null) {
		result = TypesFactory.eINSTANCE.createJvmEnumAnnotationValue();
	}
	JvmEnumerationLiteral enumLiteralProxy = proxies.createEnumLiteral(value, desc);
	((InternalEList<JvmEnumerationLiteral>) ((JvmEnumAnnotationValue) result).getValues()).addUnique(enumLiteralProxy);
}
 

/** Create a JvmType for a Python type.
 *
 * @param pythonName the python type name.
 * @return the type.
 */
@SuppressWarnings("static-method")
protected JvmType newType(String pythonName) {
	final JvmGenericType type = TypesFactory.eINSTANCE.createJvmGenericType();
	final int index = pythonName.indexOf("."); //$NON-NLS-1$
	if (index <= 0) {
		type.setSimpleName(pythonName);
	} else {
		type.setPackageName(pythonName.substring(0, index - 1));
		type.setSimpleName(pythonName.substring(index + 1));
	}
	return type;
}
 

@Test
public void testInterfaceDescription_02() {
	JvmGenericType interfaceType = TypesFactory.eINSTANCE.createJvmGenericType();
	interfaceType.setInterface(false);
	interfaceType.setPackageName("foo");
	interfaceType.setSimpleName("MyType");
	List<IEObjectDescription> list = new ArrayList<>();
	descriptionStrategy.createEObjectDescriptions(interfaceType, it -> list.add(it));
	Assert.assertFalse(list.stream().anyMatch(
			it -> "true".equals(it.getUserData(JvmTypesResourceDescriptionStrategy.IS_INTERFACE))));
}
 

/**
 * {@inheritDoc}
 * 
 * Returns the value of the 'Type' reference. If there is no type set, 
 * a reference to <code>java.lang.Object</code> is assumed.
 */
@Override
public JvmType getType() {
	if (type == null) {
		JvmGenericType objectType = TypesFactory.eINSTANCE.createJvmGenericType();
		String objectClassName = Object.class.getName();
		((InternalEObject) objectType).eSetProxyURI(URIHelperConstants.OBJECTS_URI.appendSegment(objectClassName).appendFragment(objectClassName));
		setType(objectType);
	}
	return super.getType();
}
 

/**
 * @since 2.4
 */
protected JvmConstructor createConstructor(StringBuilder qualifiedName, String handleIdentifier, String[] path, IMethodBinding method) {
	JvmConstructor result = TypesFactory.eINSTANCE.createJvmConstructor();
	enhanceGenericDeclaration(result, method.getTypeParameters());
	enhanceExecutable(qualifiedName, handleIdentifier, path, result, method);
	createAnnotationValues(method, result);
	return result;
}