示例#1
0
    @Override
    public boolean replaceChild(Element child, Element by) {
      if (child == getTarget()) {
        setTarget((Expression) by);
        return true;
      }
      if (child == getFunction()) {
        setFunction((Expression) by);
        return true;
      }
      // return replaceChild(arguments, Expression.class, this, child, by);
      int i = indexOf(child, arguments);
      if (i >= 0) {
        Expression old;
        if (by == null) old = arguments.remove(i).getValue();
        else old = arguments.get(i).setValue((Expression) by);

        if (old != by) {
          if (old != null) old.setParentElement(null);

          if (by != null) by.setParentElement(this);
        }
        return true;
      }

      return super.replaceChild(child, by);
    }
示例#2
0
  @SuppressWarnings("unchecked")
  public boolean insertChild(Element existingChild, Element childToInsert, boolean before) {
    if (elementListGettersAndSetters == null) {
      elementListGettersAndSetters = new ArrayList<GetterAndSetterInfo>();
      GettersAndSettersHelper gettersAndSetters = getGettersAndSetters();

      for (Map.Entry<String, GetterAndSetterInfo> e :
          gettersAndSetters.gettersAndSetters.entrySet()) {
        GetterAndSetterInfo p = e.getValue();
        if (!p.isFull()) continue;

        Type returnType = p.getter.getGenericReturnType();
        if (returnType instanceof ParameterizedType) {
          ParameterizedType paramReturnType = (ParameterizedType) returnType;
          Type rawType = paramReturnType.getRawType();
          Type[] typeArguments = paramReturnType.getActualTypeArguments();
          Type typeArgument = typeArguments.length == 1 ? typeArguments[0] : null;
          if (typeArgument != null && typeArgument instanceof Class && rawType instanceof Class) {
            Class<?> typeClass = (Class<?>) typeArgument;
            Class<?> rawClass = (Class<?>) rawType;
            if (Element.class.isAssignableFrom(typeClass)
                && List.class.isAssignableFrom(rawClass)) {
              p.elementType = (Class<Element>) typeClass;
              elementListGettersAndSetters.add(
                  p); // new ListGetterAndSetterInfo(e.getKey(), (Class<Element>)typeClass,
                      // p.getter, p.setter));
            }
          }
        }
      }
    }
    Class<?> t = existingChild.getClass(), t2 = childToInsert.getClass();
    for (GetterAndSetterInfo info : elementListGettersAndSetters) {
      if (!info.elementType.isAssignableFrom(t) || !info.elementType.isAssignableFrom(t2)) continue;

      try {
        List<Element> list = (List<Element>) info.getter.invoke(this);
        if (list instanceof SemiUnmodifiableList)
          list = ((SemiUnmodifiableList<Element>) list).getList();
        int i = indexOfInstance(existingChild, list);
        if (i < 0) continue;

        list.add(before ? i : i + 1, childToInsert);
        childToInsert.setParentElement(this);
        return true;
      } catch (Exception e) {
        throw new RuntimeException("Implementation bug in " + Element.class + ".insertChild !", e);
      }
    }
    return false;
  }
示例#3
0
  @SuppressWarnings("unchecked")
  public static <T extends Element> boolean replaceChild(
      List<T> list, Class<T> type, Element parent, Element child, Element by) {
    int i = indexOfInstance(child, list);

    if (i >= 0) {
      T old;
      if (by == null) old = list.remove(i);
      else old = list.set(i, type == null ? (T) by : type.cast(by));

      if (old != by) {
        if (old != null) old.setParentElement(null);

        if (by != null) by.setParentElement(parent);
      }
      return true;
    }

    return false;
  }