コード例 #1
0
  /**
   * 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;
  }
コード例 #2
0
  /**
   * 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);
    }
  }
コード例 #3
0
  /**
   * 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
    }
  }