refs) throws AmbiguousConstructorException {
boolean found = false;
if (!"".equals(parameter.getName())) {
// Match by name
JavaElementImpl prop = props.get(parameter.getName());
if (prop != null && prop.getType() == parameter.getType()) {
parameter.setClassifer(Property.class);
return true;
}
JavaElementImpl ref = refs.get(parameter.getName());
if (ref != null && ref.getType() == parameter.getType()) {
parameter.setClassifer(Reference.class);
return true;
}
}
for (JavaElementImpl property : props.values()) {
if (property.getType() == parameter.getType()) {
if (found) {
throw new AmbiguousConstructorException("Ambiguous property or reference for constructor type",
(Member)parameter.getAnchor());
}
parameter.setClassifer(Property.class);
parameter.setName(property.getName());
found = true;
// do not break since ambiguities must be checked, i.e. more
// than one prop or ref of the same type
}
}
for (JavaElementImpl reference : refs.values()) {
if (reference.getType() == parameter.getType()) {
if (found) {
throw new AmbiguousConstructorException("Ambiguous property or reference for constructor type",
(Member)parameter.getAnchor());
}
parameter.setClassifer(Reference.class);
parameter.setName(reference.getName());
found = true;
// do not break since ambiguities must be checked, i.e. more
// than one prop or ref of the same type
}
}
return found;
}
/**
* Returns true if a given type is reference according to the SCA
* specification rules for determining reference types The following rules
* are used to determine whether an unannotated field or setter method is a
* property or reference:
*
* - If its type is simple, then it is a property.
*
- If its type is complex, then if the type is an interface marked by
*
* @Remotable, then it is a reference; otherwise, it is a property.
*
- Otherwise, if the type associated with the member is an
* array or a java.util.Collection, the basetype is the element
* type of the array or the parameterized type of the
* Collection; otherwise the basetype is the member type. If the
* basetype is an interface with an
* @Remotable or
* @Service annotation then the member is defined as a reference. Otherwise,
* it is defined as a property.
*
*
* The name of the reference or of the property is derived from the
* name found on the setter method or on the field.
*/
private boolean isReferenceType(Class cls, Type genericType) {
Class baseType = JavaIntrospectionHelper.getBaseType(cls, genericType);
return baseType.isInterface() && baseType.isAnnotationPresent(Remotable.class);
}
/**
* Returns true if the given operation is defined in the collection of
* service interfaces
*/
private boolean isInServiceInterface(Method operation, List services) {
for (org.apache.tuscany.sca.assembly.Service service : services) {
Interface interface1 = service.getInterfaceContract().getInterface();
if (interface1 instanceof JavaInterface) {
Class clazz = ((JavaInterface)interface1).getJavaClass();
if (isMethodMatched(clazz, operation)) {
return true;
}
}
}
return false;
}
/**
* Test if the class declares a method which matches the signature of the
* given method
*
* @param clazz
* @param method
* @return
*/
private boolean isMethodMatched(Class clazz, Method method) {
if (method.getDeclaringClass() == clazz) {
return true;
}
Method[] methods = clazz.getMethods();
for (Method m : methods) {
if (JavaIntrospectionHelper.exactMethodMatch(method, m)) {
return true;
}
}
return false;
}
/**
* Creates a mapped property.
*
* @param name the property name
* @param paramType the property type
*/
private org.apache.tuscany.sca.assembly.Property createProperty(String name, Class paramType) {
org.apache.tuscany.sca.assembly.Property property = assemblyFactory.createProperty();
property.setName(name);
property.setXSDType(JavaXMLMapper.getXMLType(paramType));
return property;
}
private boolean isAnnotated(JavaParameterImpl parameter) {
for (Annotation annotation : parameter.getAnnotations()) {
Class annotType = annotation.annotationType();
if (annotType.equals(Property.class) || annotType.equals(Reference.class)
|| annotType.equals(Resource.class)) {
return true;
}
}
return false;
}
public boolean areUnique(JavaParameterImpl[] parameters) {
Set set = new HashSet(parameters.length);
for (JavaParameterImpl p : parameters) {
if (!set.add(p.getType())) {
return false;
}
}
return true;
}
public org.apache.tuscany.sca.assembly.Reference createReference(String name, Class paramType)
throws IntrospectionException {
org.apache.tuscany.sca.assembly.Reference reference = assemblyFactory.createReference();
reference.setName(name);
JavaInterfaceContract interfaceContract = javaInterfaceFactory.createJavaInterfaceContract();
reference.setInterfaceContract(interfaceContract);
try {
JavaInterface callInterface = javaInterfaceFactory.createJavaInterface(paramType);
reference.getInterfaceContract().setInterface(callInterface);
if (callInterface.getCallbackClass() != null) {
JavaInterface callbackInterface = javaInterfaceFactory.createJavaInterface(callInterface.getCallbackClass());
reference.getInterfaceContract().setCallbackInterface(callbackInterface);
}
reference.setMultiplicity(Multiplicity.ZERO_ONE);
} catch (InvalidInterfaceException e1) {
throw new IntrospectionException(e1);
}
// FIXME: This part seems to have already been taken care above!!
try {
processCallback(paramType, reference);
} catch (InvalidServiceTypeException e) {
throw new IntrospectionException(e);
}
return reference;
}
public org.apache.tuscany.sca.assembly.Service createService(Class interfaze) throws InvalidInterfaceException {
org.apache.tuscany.sca.assembly.Service service = assemblyFactory.createService();
service.setName(interfaze.getSimpleName());
JavaInterfaceContract interfaceContract = javaInterfaceFactory.createJavaInterfaceContract();
service.setInterfaceContract(interfaceContract);
JavaInterface callInterface = javaInterfaceFactory.createJavaInterface(interfaze);
service.getInterfaceContract().setInterface(callInterface);
if (callInterface.getCallbackClass() != null) {
JavaInterface callbackInterface = javaInterfaceFactory.createJavaInterface(callInterface.getCallbackClass());
service.getInterfaceContract().setCallbackInterface(callbackInterface);
}
Interface javaInterface = service.getInterfaceContract().getInterface();
javaInterface.setRemotable(interfaze.getAnnotation(Remotable.class) != null);
service.getInterfaceContract().setInterface(javaInterface);
return service;
}
public void processCallback(Class interfaze, Contract contract) throws InvalidServiceTypeException {
Callback callback = interfaze.getAnnotation(Callback.class);
if (callback != null && !Void.class.equals(callback.value())) {
Class callbackClass = callback.value();
JavaInterface javaInterface;
try {
javaInterface = javaInterfaceFactory.createJavaInterface(callbackClass);
contract.getInterfaceContract().setCallbackInterface(javaInterface);
} catch (InvalidInterfaceException e) {
throw new InvalidServiceTypeException("Invalid callback interface "+callbackClass, interfaze);
}
} else if (callback != null && Void.class.equals(callback.value())) {
throw new InvalidServiceTypeException("No callback interface specified on annotation", interfaze);
}
}
public boolean injectionAnnotationsPresent(Annotation[][] annots) {
for (Annotation[] annotations : annots) {
for (Annotation annotation : annotations) {
Class annotType = annotation.annotationType();
if (annotType.equals(Property.class) || annotType.equals(Reference.class)
|| annotType.equals(Resource.class)) {
return true;
}
}
}
return false;
}
}