Java 类javax.validation.ElementKind 实例源码

public void validateAdditionalRules(ValidationErrors errors) {
    // all previous validations return no errors
    if (crossFieldValidate && errors.isEmpty()) {
        BeanValidation beanValidation = AppBeans.get(BeanValidation.NAME);

        Validator validator = beanValidation.getValidator();
        Set<ConstraintViolation<Entity>> violations = validator.validate(getItem(), UiCrossFieldChecks.class);

        violations.stream()
                .filter(violation -> {
                    Path propertyPath = violation.getPropertyPath();

                    Path.Node lastNode = Iterables.getLast(propertyPath);
                    return lastNode.getKind() == ElementKind.BEAN;
                })
                .forEach(violation -> errors.add(violation.getMessage()));
    }
}

/**
 * Test of extractViolationInfoFromNode method, of class ConstraintServices.
 */
@Test
public void testExtractViolationInfoFromNode() {
    System.out.println("extractViolationInfoFromNode");
    Path.Node node = mock(Path.Node.class);
    when(node.getKind()).thenReturn(ElementKind.METHOD).thenReturn(ElementKind.PARAMETER).thenReturn(ElementKind.PROPERTY);
    when(node.getName()).thenReturn("arg0").thenReturn("prop");
    doReturn(5).when(instance).getIndexFromArgname(anyString());

    ConstraintViolation cv = new ConstraintViolation();
    instance.extractViolationInfoFromNode(node, cv);
    assertThat(cv.getMessage()).isNull();
    assertThat(cv.getIndex()).isEqualTo(0);
    assertThat(cv.getProp()).isNull();
    cv = new ConstraintViolation();
    instance.extractViolationInfoFromNode(node, cv);
    assertThat(cv.getMessage()).isNull();
    assertThat(cv.getIndex()).isEqualTo(5);
    assertThat(cv.getProp()).isNull();
    cv = new ConstraintViolation();
    instance.extractViolationInfoFromNode(node, cv);
    assertThat(cv.getMessage()).isNull();
    assertThat(cv.getIndex()).isEqualTo(0);
    assertThat(cv.getProp()).isEqualTo("prop");
}

/**
 * constructor, do not use.
 */
public NodeImpl(final String name, final NodeImpl parent, final boolean isIterable,
    final Integer index, final Object key, final ElementKind kind,
    final Class<?>[] parameterTypes, final Integer parameterIndex, final Object value,
    final Class<?> containerClass, final Integer typeArgumentIndex) {
  this.name = name;
  this.parent = parent;
  this.index = index;
  this.key = key;
  this.value = value;
  this.isIterableValue = isIterable;
  this.kind = kind;
  this.parameterTypes = parameterTypes;
  this.parameterIndex = parameterIndex;
  this.containerClass = containerClass;
  this.typeArgumentIndex = typeArgumentIndex;
}

/**
 * create property node.
 *
 * @param name name of the node
 * @param parent parent node
 * @return new node implementation
 */
// TODO It would be nicer if we could return PropertyNode
public static NodeImpl createPropertyNode(final String name, final NodeImpl parent) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.PROPERTY, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}

/**
 * create container element node.
 *
 * @param name name of the node
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createContainerElementNode(final String name, final NodeImpl parent) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.CONTAINER_ELEMENT, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}

/**
 * create parameter node.
 *
 * @param name name of the node
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createParameterNode(final String name, final NodeImpl parent,
    final int parameterIndex) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.PARAMETER, //
      EMPTY_CLASS_ARRAY, //
      parameterIndex, //
      null, //
      null, //
      null //
  );
}

/**
 * create cross parameter node node.
 *
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createCrossParameterNode(final NodeImpl parent) {
  return new NodeImpl( //
      CROSS_PARAMETER_NODE_NAME, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.CROSS_PARAMETER, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}

/**
 * create method node.
 *
 * @param name name of the node
 * @param parent parent node
 * @param parameterTypes parameter types
 * @return new node implementation
 */
public static NodeImpl createMethodNode(final String name, final NodeImpl parent,
    final Class<?>[] parameterTypes) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.METHOD, //
      parameterTypes, //
      null, //
      null, //
      null, //
      null //
  );
}

/**
 * create constructor node.
 *
 * @param name name of the node
 * @param parent parent node
 * @param parameterTypes parameter types
 * @return new node implementation
 */
public static NodeImpl createConstructorNode(final String name, final NodeImpl parent,
    final Class<?>[] parameterTypes) {
  return new NodeImpl( //
      name, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.CONSTRUCTOR, //
      parameterTypes, //
      null, //
      null, //
      null, //
      null //
  );
}

/**
 * create return node.
 *
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createReturnValue(final NodeImpl parent) {
  return new NodeImpl( //
      RETURN_VALUE_NODE_NAME, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.RETURN_VALUE, //
      EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}

@SuppressWarnings("unchecked")
@Override
public <T extends Path.Node> T as(final Class<T> nodeType) throws ClassCastException { // NOPMD
  if (this.kind == ElementKind.BEAN && nodeType == BeanNode.class
      || this.kind == ElementKind.CONSTRUCTOR && nodeType == ConstructorNode.class
      || this.kind == ElementKind.CROSS_PARAMETER && nodeType == CrossParameterNode.class
      || this.kind == ElementKind.METHOD && nodeType == MethodNode.class
      || this.kind == ElementKind.PARAMETER && nodeType == ParameterNode.class
      || this.kind == ElementKind.PROPERTY && (nodeType == PropertyNode.class
          || nodeType == org.hibernate.validator.path.PropertyNode.class)
      || this.kind == ElementKind.RETURN_VALUE && nodeType == ReturnValueNode.class
      || this.kind == ElementKind.CONTAINER_ELEMENT && (nodeType == ContainerElementNode.class
          || nodeType == org.hibernate.validator.path.ContainerElementNode.class)) {
    return (T) this;
  }

  throw LOG.getUnableToNarrowNodeTypeException(this.getClass(), this.kind, nodeType);
}

/**
 * Determine the response status (400 or 500) from the given BV exception.
 *
 * @param violation BV exception.
 * @return response status (400 or 500).
 */
public static Response.Status getResponseStatus(final ConstraintViolationException violation) {
    final Iterator<ConstraintViolation<?>> iterator = violation.getConstraintViolations().iterator();

    if (iterator.hasNext()) {
        for (final Path.Node node : iterator.next().getPropertyPath()) {
            final ElementKind kind = node.getKind();

            if (ElementKind.RETURN_VALUE.equals(kind)) {
                return Response.Status.INTERNAL_SERVER_ERROR;
            }
        }
    }

    return Response.Status.BAD_REQUEST;
}

@Override
public ValidationErrorMessage createBody(ConstraintViolationException ex, HttpServletRequest req) {

    ErrorMessage tmpl = super.createBody(ex, req);
    ValidationErrorMessage msg = new ValidationErrorMessage(tmpl);

    for (ConstraintViolation<?> violation : ex.getConstraintViolations()) {
        Node pathNode = findLastNonEmptyPathNode(violation.getPropertyPath());

        // path is probably useful only for properties (fields)
        if (pathNode != null && pathNode.getKind() == ElementKind.PROPERTY) {
            msg.addError(pathNode.getName(), convertToString(violation.getInvalidValue()), violation.getMessage());

        // type level constraints etc.
        } else {
            msg.addError(violation.getMessage());
        }
    }
    return msg;
}

@Override
public void beforeNode(Object obj, DescriptorPath path) {
  if (path.getHeadNode().getKind() != ElementKind.BEAN) {
    return;
  }
  BeanDescriptorNode node = path.getHeadNode().as(BeanDescriptorNode.class);
  Named named = ReflectionHelper.findAnnotation(node.getBean().getClass(), Named.class);
  Referenced referenced = ReflectionHelper.findAnnotation(node.getBean().getClass(), Referenced.class);
  if (referenced != null) {
    if (referenced.as().length == 0 && named == null) {
      throw new IllegalStateException("The @Referenced annotation requires the @Named to also exist.");
    }
    ReferenceType type = referenced.type();
    references.put(type, path.onlyInclude(ElementKind.BEAN));
  }
}

private void callReferenceConstraints(Object obj, DescriptorPath path) {
  DescriptorNode node = path.getHeadNode();
  for (ReferenceConstraint<T> constraint : constraints) {
    if (node.getClass().isAssignableFrom(constraint.getNodeType()))  {
      continue;
    }

    Annotation annotation;
    Class<? extends  Annotation> annClass = constraint.getAnnotationType();
    if (node.getKind() == ElementKind.BEAN) {
      annotation = ReflectionHelper.findAnnotation(obj.getClass(), annClass);
    } else if (node.getKind() == ElementKind.PROPERTY) {
      Method method = node.as(PropertyNode.class).getMethod();
      annotation = ReflectionHelper.findAnnotation(method, annClass);
    } else {
      throw new IllegalStateException(node.getKind() + " is an unsupported type.");
    }

    if (annotation == null) {
      continue;
    }

    this.violations.addAll(constraint.checkConstraint(annotation, obj, path, allowedRefs));
  }
}

private String printPropertyPath(Path path) {
  if (path == null) return "UNKNOWN";

  String propertyPath = "";
  Path.Node parameterNode = null;
  // Construct string representation of property path.
  // This will strip away any other nodes added by RESTEasy (method, parameter, ...).
  for (Path.Node node : path) {
    if (node.getKind() == ElementKind.PARAMETER) {
      parameterNode = node;
    }

    if (node.getKind() == ElementKind.PROPERTY) {
      if (!propertyPath.isEmpty()) {
        propertyPath += ".";
      }

      propertyPath += node;
    }
  }

  if (propertyPath.isEmpty() && parameterNode != null) {
    // No property path constructed, assume this is a validation failure on a request parameter.
    propertyPath = parameterNode.toString();
  }

  return propertyPath;
}

/**
 * Translate validated bean and root path into validated resource and
 * resource path. For example, embeddables belonging to an entity document
 * are mapped back to an entity violation and a proper path to the
 * embeddable attribute.
 *
 * @param violation to compute the reference
 * @return computaed reference
 */
private ResourceRef resolvePath(ConstraintViolation<?> violation) {
    Object resource = violation.getRootBean();

    Object nodeObject = resource;
    ResourceRef ref = new ResourceRef(resource);

    Iterator<Node> iterator = violation.getPropertyPath().iterator();
    while (iterator.hasNext()) {
        Node node = iterator.next();

        // ignore methods/parameters
        if (node.getKind() == ElementKind.METHOD) {
            continue;
        }
        if (node.getKind() == ElementKind.PARAMETER) {
            resource = getParameterValue(node);
            nodeObject = resource;
            ref = new ResourceRef(resource);
            assertResource(resource);
            continue;
        }

        // visit list, set, map references
        nodeObject = ref.getNodeReference(nodeObject, node);
        ref.visitNode(nodeObject);

        // visit property
        nodeObject = ref.visitProperty(nodeObject, node);
    }

    return ref;
}

public Object visitProperty(Object nodeObject, Node node) {
    Object next;
    if (node.getKind() == ElementKind.PROPERTY) {
        next = PropertyUtils.getProperty(nodeObject, node.getName());
    }
    else if (node.getKind() == ElementKind.BEAN) {
        next = nodeObject;
    }
    else {
        throw new UnsupportedOperationException("unknown node: " + node);
    }

    if (node.getName() != null) {
        appendSeparator();
        if (!isResource(nodeObject.getClass()) || isPrimaryKey(nodeObject.getClass(), node.getName())) {
            // continue along attributes path or primary key on root
            appendSourcePointer(node.getName());
        }
        else if (isAssociation(nodeObject.getClass(), node.getName())) {
            appendSourcePointer("/data/relationships/");
            appendSourcePointer(node.getName());
        }
        else {

            appendSourcePointer("/data/attributes/");
            appendSourcePointer(node.getName());
        }
    }
    return next;
}

@Override
public ElementKind getKind() {
    if (path == null) {
        return ElementKind.BEAN;
    } else {
        return ElementKind.PROPERTY;
    }
}

private String printPropertyPath(Path path) {
    if (path == null) {
        return "UNKNOWN";
    }

    String propertyPath = "";
    Path.Node parameterNode = null;
    // Construct string representation of property path.
    // This will strip away any other nodes added by RESTEasy (method, parameter, ...).
    for (Path.Node node : path) {
        if (node.getKind() == ElementKind.PARAMETER) {
            parameterNode = node;
        }

        if (node.getKind() == ElementKind.PROPERTY) {
            if (!propertyPath.isEmpty()) {
                propertyPath += ".";
            }
            propertyPath += node;
        }
    }

    if (propertyPath.isEmpty() && parameterNode != null) {
        // No property path constructed, assume this is a validation failure on a request parameter.
        propertyPath = parameterNode.toString();
    }
    return propertyPath;
}

@Override
public String toString() {
    final StringBuilder b = new StringBuilder();
    for (final Node node : nodes) {
        if (b.length() > 0 && node.getKind() == ElementKind.PROPERTY) {
            b.append('.');
        }
        b.append(node.toString());
    }
    return b.toString();
}

@Test
public void testSimplePath() {
    final MinijaxPath path = new MinijaxPath(Arrays.asList(new MinijaxPropertyNode(0, "foo")));
    assertEquals("foo", path.toString());

    for (final Node node : path) {
        assertTrue(node.isInIterable());
        assertNotNull(node.getName());
        assertNull(node.getKey());
        assertEquals(ElementKind.PROPERTY, node.getKind());
        assertEquals(node, node.as(PropertyNode.class));
        assertNull(node.as(PropertyNode.class).getContainerClass());
        assertEquals(0, (int) node.as(PropertyNode.class).getTypeArgumentIndex());
    }
}

/**
 * Return the property path from the given validation error.
 */
private String getPropertyPath(final ConstraintViolation<?> error) {
    if (((PathImpl) error.getPropertyPath()).getLeafNode().getKind() == ElementKind.PARAMETER) {
        // JSR-349 - Parameter, drop parent context
        return ((PathImpl) error.getPropertyPath()).getLeafNode().getName();
    }
    // JSR-303 - Bean violation
    return error.getPropertyPath().toString();
}

private static String constructJsonPath(Path path) {
    StringBuilder jsonPath = new StringBuilder("#");
    path.forEach(pathComponent -> {
        if (pathComponent.getKind() == ElementKind.PROPERTY) {
            jsonPath.append("/").append(pathComponent.getName());
        }
    });
    return jsonPath.toString();
}

private Status getResponseStatus(final ConstraintViolation<?> violation) {
  for (Path.Node node : violation.getPropertyPath()) {
    ElementKind kind = node.getKind();

    if (ElementKind.RETURN_VALUE.equals(kind)) {
      return Status.INTERNAL_SERVER_ERROR;
    }
  }

  return Status.BAD_REQUEST;
}

public ValidationResponse(final ConstraintViolationException cause) {
  super(false, new ArrayList<>());
  //noinspection ThrowableResultOfMethodCallIgnored
  checkNotNull(cause);
  Set<ConstraintViolation<?>> violations = cause.getConstraintViolations();
  if (violations != null && !violations.isEmpty()) {
    for (ConstraintViolation<?> violation : violations) {
      List<String> entries = new ArrayList<>();
      // iterate path to get the full path
      Iterator<Node> it = violation.getPropertyPath().iterator();
      while (it.hasNext()) {
        Node node = it.next();
        if (ElementKind.PROPERTY == node.getKind() || (ElementKind.PARAMETER == node.getKind() && !it.hasNext())) {
          if (node.getKey() != null) {
            entries.add(node.getKey().toString());
          }
          entries.add(node.getName());
        }
      }
      if (entries.isEmpty()) {
        if (messages == null) {
          messages = new ArrayList<>();
        }
        messages.add(violation.getMessage());
      }
      else {
        if (errors == null) {
          errors = new HashMap<>();
        }
        errors.put(Joiner.on('.').join(entries), violation.getMessage());
      }
    }
  }
  else if (cause.getMessage() != null) {
    messages = new ArrayList<>();
    messages.add(cause.getMessage());
  }
}

protected String derivePropertyPathByNode(ConstraintViolation<Object> vio) {
    final StringBuilder sb = new StringBuilder();
    final Path path = vio.getPropertyPath();
    int elementCount = 0;
    for (Path.Node node : path) {
        if (node.isInIterable()) { // building e.g. "[0]" of seaList[0]
            Object nodeIndex = node.getIndex();
            if (nodeIndex == null) {
                nodeIndex = node.getKey(); // null if e.g. iterable
            }
            sb.append("[").append(nodeIndex != null ? nodeIndex : "").append("]"); // e.g. [0] or []
        }
        final String nodeName = node.getName();
        if (nodeName != null && node.getKind() == ElementKind.PROPERTY) {
            // _/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
            // if e.g.
            //  private List<@Required String> seaList;
            // then path is "seaList[0].<list element>" since Hibernate Validator-6.x
            // <list element> part is unneeded for property path of message so skip here
            // _/_/_/_/_/_/_/_/_/_/
            if (!nodeName.startsWith("<")) { // except e.g. <list element>
                if (elementCount > 0) {
                    sb.append(".");
                }
                sb.append(nodeName);
                ++elementCount;
            }
        }
    }
    return sb.toString(); // e.g. sea, sea.hangar, seaList[0], seaList[0].hangar
}

void extractViolationInfoFromNode(Path.Node node, ConstraintViolation cv) {
    ElementKind kind = node.getKind();
    logger.debug("Kind:{} Index:{} Key:{} Name:{}", kind, node.getIndex(), node.getKey(), node.getName());

    if (ElementKind.PARAMETER.equals(kind)) {
        cv.setIndex(getIndexFromArgname(node.getName()));
    } else if (ElementKind.PROPERTY.equals(kind)) {
        cv.setProp(node.getName());
    }
}

/**
 * create bean node.
 *
 * @param parent parent node
 * @return new node implementation
 */
public static NodeImpl createBeanNode(final NodeImpl parent) {
  return new NodeImpl( //
      null, //
      parent, //
      false, //
      null, //
      null, //
      ElementKind.BEAN, EMPTY_CLASS_ARRAY, //
      null, //
      null, //
      null, //
      null //
  );
}

@Override
public Class<?> getContainerClass() {
  Contracts.assertTrue(
      this.kind == ElementKind.BEAN || this.kind == ElementKind.PROPERTY
          || this.kind == ElementKind.CONTAINER_ELEMENT,
      "getContainerClass() may only be invoked for nodes of type ElementKind.BEAN, "
          + "ElementKind.PROPERTY or ElementKind.CONTAINER_ELEMENT.");
  if (this.parent == null) {
    return null;
  }
  return this.parent.containerClass;
}

@Override
public Integer getTypeArgumentIndex() {
  Contracts.assertTrue(
      this.kind == ElementKind.BEAN || this.kind == ElementKind.PROPERTY
          || this.kind == ElementKind.CONTAINER_ELEMENT,
      "getTypeArgumentIndex() may only be invoked for nodes of type ElementKind.BEAN, "
          + "ElementKind.PROPERTY or ElementKind.CONTAINER_ELEMENT.");
  if (this.parent == null) {
    return null;
  }
  return this.parent.typeArgumentIndex;
}

public NodeImpl setLeafNodeValueIfRequired(final Object value) {
  // The value is only exposed for property and container element nodes
  if (this.currentLeafNode.getKind() == ElementKind.PROPERTY
      || this.currentLeafNode.getKind() == ElementKind.CONTAINER_ELEMENT) {
    this.requiresWriteableNodeList();

    this.currentLeafNode = NodeImpl.setPropertyValue(this.currentLeafNode, value);

    this.nodeList.set(this.nodeList.size() - 1, this.currentLeafNode);

    // the property value is not part of the NodeImpl hashCode so we don't need to reset the
    // PathImpl hashCode
  }
  return this.currentLeafNode;
}

public ClassCastException getUnableToNarrowNodeTypeException(
    final Class<? extends NodeImpl> pclass, final ElementKind pkind, final Class<?> pnodeType) {
  final ClassCastException result = new ClassCastException();
  final StackTraceElement[] st = result.getStackTrace();
  result.setStackTrace(Arrays.copyOfRange(st, 1, st.length));
  return result;
}

protected NodeImpl(final String pname,
    final org.hibernate.validator.internal.engine.path.NodeImpl pparent, final boolean pindexable,
    final Integer pindex, final Object pkey, final ElementKind pkind,
    final Class<?>[] pparameterTypes, final Integer pparameterIndex, final Object pvalue) {
  super(pname, pparent, pindexable, pindex, pkey, pkind, pparameterTypes, pparameterIndex, pvalue,
      null, null);
}

private Map<String, ExecutableDescriptorImpl> getConstrainedMethodsAsDescriptors() {
    Map<String, ExecutableDescriptorImpl> constrainedMethodDescriptors = newHashMap();

    for (ExecutableMetaData executableMetaData : executableMetaDataMap.values()) {
        if (executableMetaData.getKind() == ElementKind.METHOD && executableMetaData.isConstrained()) {
            constrainedMethodDescriptors.put(executableMetaData.getIdentifier(), executableMetaData.asDescriptor(
                    defaultGroupSequenceIsRedefined(), getDefaultGroupSequence(null)));
        }
    }

    return constrainedMethodDescriptors;
}

private Map<String, ConstructorDescriptor> getConstrainedConstructorsAsDescriptors() {
    Map<String, ConstructorDescriptor> constrainedMethodDescriptors = newHashMap();

    for (ExecutableMetaData executableMetaData : executableMetaDataMap.values()) {
        if (executableMetaData.getKind() == ElementKind.CONSTRUCTOR && executableMetaData.isConstrained()) {
            constrainedMethodDescriptors.put(executableMetaData.getIdentifier(), executableMetaData.asDescriptor(
                    defaultGroupSequenceIsRedefined(), getDefaultGroupSequence(null)));
        }
    }

    return constrainedMethodDescriptors;
}

private SetMultimap<ReferenceType, String> getRelatedPaths(Object obj, DescriptorPath path) {
  SetMultimap<ReferenceType, String> refs = LinkedHashMultimap.create();

  String additionalScope = "";
  IncludeAdditionalReferences scope = ReflectionHelper.findAnnotation(obj.getClass(), IncludeAdditionalReferences.class);
  if (scope != null) {
    additionalScope = ReflectionHelper.propertyValueByName(obj, scope.value(), String.class);
  }

  DescriptorPath trimmedPath = path.onlyInclude(ElementKind.BEAN);
  for (Map.Entry<ReferenceType, DescriptorPath> entry : allRefs.entries()) {
    DescriptorPath refPath = entry.getValue();
    DescriptorPath prefix = refPath.removeFromHead();
    if (trimmedPath.equals(prefix) || (refPath.contains(additionalScope, ElementKind.BEAN))) {
      DescriptorNode headNode = refPath.getHeadNode();
      boolean addedNames = false;
      if (ElementKind.BEAN.equals(headNode.getKind())) {
        Referenced referenced = ReflectionHelper.findAnnotation(
            ((BeanNode) headNode).getBean().getClass(), Referenced.class);
        if (null != referenced && referenced.as().length > 0) {
          for (String name : referenced.as()) {
            refs.put(entry.getKey(), name);
          }
          addedNames = true;
        }
      }
      if (!addedNames) {
        refs.put(entry.getKey(), headNode.getName());
      }
    }
  }
  return refs;
}

public DescriptorNodeImpl(String name,
                          boolean iterable,
                          Integer index,
                          Object key,
                          ElementKind kind) {
  this.name = name;
  this.iterable = iterable;
  this.index = index;
  this.key = key;
  this.kind = kind;
}

public PropertyNode(String name,
                    boolean iterable,
                    Integer index,
                    Method method) {
  super(name, iterable, index, null, ElementKind.PROPERTY);
  this.method = method;
}

public BeanNode(String name,
                Object key,
                Object bean,
                boolean isNamed) {
  super(name, false, null, key, ElementKind.BEAN);
  this.isNamed = isNamed;
  this.bean = bean;
}