/**
* Sets the indexed type of IdxPropertyPattern
*
* @param type New indexed type of the indexed property
* @throws SourceException If the modification of source code is impossible
*/
public void setIndexedType(Type type) throws SourceException {
if (this.indexedType.compareTo(type, true)) return;
// Remember the old type & old indexed type
Type oldIndexedType = this.indexedType;
Type oldType = this.type;
// Change the indexed type
if (indexedGetterMethod != null) {
indexedGetterMethod.setReturn(type);
}
if (indexedSetterMethod != null) {
MethodParameter[] params = indexedSetterMethod.getParameters();
if (params.length > 1) {
params[1].setType(type);
indexedSetterMethod.setParameters(params);
}
}
// Test if the old type of getter and seter was an array of indexedType
// if so change the type of that array.
if (oldType != null
&& oldType.isArray()
&& oldType.getElementType().compareTo(oldIndexedType, false)) {
Type newArrayType = Type.createArray(type);
super.setType(newArrayType);
}
indexedType = type;
}
/**
* Sets the non-indexed type of IdxPropertyPattern
*
* @param type New non-indexed type of the indexed property
* @throws SourceException If the modification of source code is impossible
*/
public void setType(Type type) throws SourceException {
if (this.type != null && this.type.compareTo(type, true)) return;
// Remember the old type & old indexed type
Type oldIndexedType = this.indexedType;
Type oldType = this.type;
if (oldType == null) {
this.type = type;
oldType = type;
int mode = getMode();
if (mode == READ_WRITE || mode == READ_ONLY) generateGetterMethod();
if (mode == READ_WRITE || mode == WRITE_ONLY) generateSetterMethod();
} else
// Change the type
super.setType(type);
// Test if the idexedType is the type of array and change it if so
if (type.isArray()
&& oldType.isArray()
&& oldType.getElementType().compareTo(oldIndexedType, false)) {
Type newType = type.getElementType();
if (indexedGetterMethod != null) {
indexedGetterMethod.setReturn(newType);
}
if (indexedSetterMethod != null) {
MethodParameter[] params = indexedSetterMethod.getParameters();
if (params.length > 1) {
params[1].setType(newType);
indexedSetterMethod.setParameters(params);
}
}
// Set the type to new type
setIndexedType(newType);
}
}
/**
* Resolves the indexed type of the property from type of getter and setter. Chcecks for
* conformance to Beans design patterns.
*
* @throws IntrospectionException if the property doesnt folow the design patterns
*/
private void findIndexedPropertyType() throws IntrospectionException {
indexedType = null;
if (indexedGetterMethod != null) {
MethodParameter[] params = indexedGetterMethod.getParameters();
if (params.length != 1) {
throw new IntrospectionException("bad indexed read method arg count"); // NOI18N
}
if (!params[0].getType().compareTo(Type.INT, false)) {
throw new IntrospectionException("not int index to indexed read method"); // NOI18N
}
indexedType = indexedGetterMethod.getReturn();
if (indexedType.compareTo(Type.VOID, false)) {
throw new IntrospectionException("indexed read method return void"); // NOI18N
}
}
if (indexedSetterMethod != null) {
MethodParameter params[] = indexedSetterMethod.getParameters();
if (params.length != 2) {
throw new IntrospectionException("bad indexed write method arg count"); // NOI18N
}
if (!params[0].getType().compareTo(Type.INT, false)) {
throw new IntrospectionException("non int index to indexed write method"); // NOI18N
}
if (indexedType != null && !indexedType.compareTo(params[1].getType(), false)) {
throw new IntrospectionException(
"type mismatch between indexed read and write methods"); // NOI18N
}
indexedType = params[1].getType();
}
// type = indexedType;
Type propType = getType();
if (propType != null
&& (!propType.isArray() || !propType.getElementType().compareTo(indexedType, false))) {
throw new IntrospectionException(
"type mismatch between property type and indexed type"); // NOI18N
}
}
