public void linkShadowSources(DescriptorPolicy descriptorPolicy) { CustomShadowVariable shadowVariableAnnotation = variableMemberAccessor.getAnnotation(CustomShadowVariable.class); SolutionDescriptor solutionDescriptor = entityDescriptor.getSolutionDescriptor(); CustomShadowVariable.Source[] sources = shadowVariableAnnotation.sources(); sourceVariableDescriptorList = new ArrayList<VariableDescriptor>(sources.length); for (CustomShadowVariable.Source source : sources) { EntityDescriptor sourceEntityDescriptor; Class<?> sourceEntityClass = source.entityClass(); if (sourceEntityClass.equals(CustomShadowVariable.Source.NullEntityClass.class)) { sourceEntityDescriptor = entityDescriptor; } else { sourceEntityDescriptor = solutionDescriptor.findEntityDescriptor(sourceEntityClass); if (sourceEntityDescriptor == null) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + CustomShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with a sourceEntityClass (" + sourceEntityClass + ") which is not a valid planning entity."); } } String sourceVariableName = source.variableName(); VariableDescriptor sourceVariableDescriptor = sourceEntityDescriptor.getVariableDescriptor(sourceVariableName); if (sourceVariableDescriptor == null) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + CustomShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with sourceVariableName (" + sourceVariableName + ") which is not a valid planning variable on entityClass (" + sourceEntityDescriptor.getEntityClass() + ").\n" + entityDescriptor.buildInvalidVariableNameExceptionMessage(sourceVariableName)); } sourceVariableDescriptor.registerShadowVariableDescriptor(this); sourceVariableDescriptorList.add(sourceVariableDescriptor); } }
public void linkShadowSources(DescriptorPolicy descriptorPolicy) { InverseRelationShadowVariable shadowVariableAnnotation = variableMemberAccessor.getAnnotation(InverseRelationShadowVariable.class); Class<?> variablePropertyType = getVariablePropertyType(); Class<?> masterClass; if (Collection.class.isAssignableFrom(variablePropertyType)) { Type genericType = variableMemberAccessor.getGenericType(); if (!(genericType instanceof ParameterizedType)) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with a property type (" + variablePropertyType + ") which is non parameterized collection."); } ParameterizedType parameterizedType = (ParameterizedType) genericType; Type[] typeArguments = parameterizedType.getActualTypeArguments(); if (typeArguments.length != 1) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with a property type (" + variablePropertyType + ") which is parameterized collection with an unsupported number of type arguments (" + typeArguments.length + ")."); } Type typeArgument = typeArguments[0]; if (!(typeArgument instanceof Class)) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with a property type (" + variablePropertyType + ") which is parameterized collection with an unsupported type arguments (" + typeArgument + ")."); } masterClass = ((Class) typeArgument); singleton = false; } else { masterClass = variablePropertyType; singleton = true; } EntityDescriptor sourceEntityDescriptor = getEntityDescriptor().getSolutionDescriptor().findEntityDescriptor(masterClass); if (sourceEntityDescriptor == null) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with a masterClass (" + masterClass + ") which is not a valid planning entity."); } String sourceVariableName = shadowVariableAnnotation.sourceVariableName(); sourceVariableDescriptor = sourceEntityDescriptor.getVariableDescriptor(sourceVariableName); if (sourceVariableDescriptor == null) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") with sourceVariableName (" + sourceVariableName + ") which is not a valid planning variable on entityClass (" + sourceEntityDescriptor.getEntityClass() + ").\n" + entityDescriptor.buildInvalidVariableNameExceptionMessage(sourceVariableName)); } boolean chained = (sourceVariableDescriptor instanceof GenuineVariableDescriptor) && ((GenuineVariableDescriptor) sourceVariableDescriptor).isChained(); if (singleton) { if (!chained) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") which does not return a " + Collection.class.getSimpleName() + " with sourceVariableName (" + sourceVariableName + ") which is not chained. Only a chained variable supports a singleton inverse."); } } else { if (chained) { throw new IllegalArgumentException( "The entityClass (" + entityDescriptor.getEntityClass() + ") has a " + InverseRelationShadowVariable.class.getSimpleName() + " annotated property (" + variableMemberAccessor.getName() + ") which does returns a " + Collection.class.getSimpleName() + " with sourceVariableName (" + sourceVariableName + ") which is chained. A chained variable supports only a singleton inverse."); } } sourceVariableDescriptor.registerShadowVariableDescriptor(this); }