truffle: graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java comparison

comparison graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java @ 9754:98b004bf3985

Refactoring of NodeUtil to centralize the use of reflection

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Thu, 16 May 2013 17:03:18 -0700
parents	e6fe35d64b71
children	84b944726df2

comparison

equal deleted inserted replaced

-:6c2a7fc32416
+:98b004bf3985
 /**
 * Utility class that manages the special access methods for node instances.
 */
 public class NodeUtil {
+/**
+* Interface that allows the customization of field offsets used for {@link Unsafe} field
+* accesses.
+*/
+public interface FieldOffsetProvider {
+long objectFieldOffset(Field field);
+}
+private static final FieldOffsetProvider unsafeFieldOffsetProvider = new FieldOffsetProvider() {
+@Override
+public long objectFieldOffset(Field field) {
+return unsafe.objectFieldOffset(field);
+}
+};
+public static enum NodeFieldKind {
+/** The single {@link Node#getParent() parent} field. */
+PARENT,
+/** A field annotated with {@link Child}. */
+CHILD,
+/** A field annotated with {@link Children}. */
+CHILDREN,
+/** A normal non-child data field of the node. */
+DATA
+}
+/**
+* Information about a field in a {@link Node} class.
+*/
+public static final class NodeField {
+private final NodeFieldKind kind;
+private final Class<?> type;
+private final String name;
+private long offset;
+protected NodeField(NodeFieldKind kind, Class<?> type, String name, long offset) {
+this.kind = kind;
+this.type = type;
+this.name = name;
+this.offset = offset;
+}
+public NodeFieldKind getKind() {
+return kind;
+}
+public Class<?> getType() {
+return type;
+}
+public String getName() {
+return name;
+}
+public long getOffset() {
+return offset;
+}
+public Object loadValue(Node node) {
+if (type == boolean.class) {
+return unsafe.getBoolean(node, offset);
+} else if (type == byte.class) {
+return unsafe.getByte(node, offset);
+} else if (type == short.class) {
+return unsafe.getShort(node, offset);
+} else if (type == char.class) {
+return unsafe.getChar(node, offset);
+} else if (type == int.class) {
+return unsafe.getInt(node, offset);
+} else if (type == long.class) {
+return unsafe.getLong(node, offset);
+} else if (type == float.class) {
+return unsafe.getFloat(node, offset);
+} else if (type == double.class) {
+return unsafe.getDouble(node, offset);
+} else {
+return unsafe.getObject(node, offset);
+}
+}
+}
+/**
+* Information about a {@link Node} class. A single instance of this class is allocated for
+* every subclass of {@link Node} that is used.
+*/
 public static final class NodeClass {
-private final Class parentClass;
+private static final Map<Class<?>, NodeClass> nodeClasses = new IdentityHashMap<>();
-private final long[] nodeFieldOffsets;
-private final Class[] nodeFieldClasses;
+// The comprehensive list of all fields.
-private final long[] nodeArrayFieldOffsets;
+private final NodeField[] fields;
-private final Class[] nodeArrayFieldClasses;
+// Separate arrays for the frequently accessed field offsets.
 private final long parentOffset;
-private final long[] nodeDataFieldOffsets;
+private final long[] childOffsets;
-private final Class<?>[] nodeDataFieldClasses;
+private final long[] childrenOffsets;
-private static final Map<Class<?>, NodeClass> nodeClasses = new IdentityHashMap<>();
+public static NodeClass get(Class<? extends Node> clazz) {
-public static NodeClass get(Class<?> clazz) {
 NodeClass nodeClass = nodeClasses.get(clazz);
 if (nodeClass == null) {
-nodeClass = new NodeClass(clazz);
+nodeClass = new NodeClass(clazz, unsafeFieldOffsetProvider);
 nodeClasses.put(clazz, nodeClass);
 }
 return nodeClass;
 }
-private NodeClass(Class<?> clazz) {
+public NodeClass(Class<? extends Node> clazz, FieldOffsetProvider fieldOffsetProvider) {
-// scan object fields
+List<NodeField> fieldsList = new ArrayList<>();
-Class<?> parentClassTmp = null;
+List<Long> parentOffsetsList = new ArrayList<>();
-List<Long> nodeFieldOffsetsList = new ArrayList<>();
+List<Long> childOffsetsList = new ArrayList<>();
-List<Class<?>> nodeFieldClassesList = new ArrayList<>();
+List<Long> childrenOffsetsList = new ArrayList<>();
-List<Long> nodeArrayFieldOffsetsList = new ArrayList<>();
-List<Class<?>> nodeArrayFieldClassesList = new ArrayList<>();
+for (Field field : getAllFields(clazz)) {
-List<Long> nodeDataFieldOffsetList = new ArrayList<>();
-List<Class<?>> nodeDataFieldClassList = new ArrayList<>();
-Field[] fields = getAllFields(clazz);
-long parentOffsetTemp = -1;
-for (Field field : fields) {
 if (Modifier.isStatic(field.getModifiers()) || field.isSynthetic()) {
 continue;
 }
-// Node fields
+NodeFieldKind kind;
-if (Node.class.isAssignableFrom(field.getType()) && field.getName().equals("parent")) {
+if (Node.class.isAssignableFrom(field.getType()) && field.getName().equals("parent") && field.getDeclaringClass() == Node.class) {
-parentOffsetTemp = unsafe.objectFieldOffset(field);
+kind = NodeFieldKind.PARENT;
-parentClassTmp = field.getType();
+parentOffsetsList.add(fieldOffsetProvider.objectFieldOffset(field));
 } else if (Node.class.isAssignableFrom(field.getType()) && field.getAnnotation(Child.class) != null) {
-nodeFieldOffsetsList.add(unsafe.objectFieldOffset(field));
+kind = NodeFieldKind.CHILD;
-nodeFieldClassesList.add(field.getType());
+childOffsetsList.add(fieldOffsetProvider.objectFieldOffset(field));
-} else if (field.getType().getComponentType() != null && Node.class.isAssignableFrom(field.getType().getComponentType()) && field.getAnnotation(Children.class) != null) {
+} else if (field.getType().isArray() && Node.class.isAssignableFrom(field.getType().getComponentType()) && field.getAnnotation(Children.class) != null) {
-nodeArrayFieldOffsetsList.add(unsafe.objectFieldOffset(field));
+kind = NodeFieldKind.CHILDREN;
-nodeArrayFieldClassesList.add(field.getType());
+childrenOffsetsList.add(fieldOffsetProvider.objectFieldOffset(field));
 } else {
-nodeDataFieldOffsetList.add(unsafe.objectFieldOffset(field));
+kind = NodeFieldKind.DATA;
-nodeDataFieldClassList.add(field.getType());
+}
-}
+fieldsList.add(new NodeField(kind, field.getType(), field.getName(), fieldOffsetProvider.objectFieldOffset(field)));
 }
-this.parentClass = parentClassTmp;
+this.fields = fieldsList.toArray(new NodeField[fieldsList.size()]);
-this.nodeFieldOffsets = toLongArray(nodeFieldOffsetsList);
+assert parentOffsetsList.size() == 1 : "must have exactly one parent field";
-this.nodeFieldClasses = nodeFieldClassesList.toArray(new Class[nodeFieldClassesList.size()]);
+this.parentOffset = parentOffsetsList.get(0);
-this.nodeArrayFieldOffsets = toLongArray(nodeArrayFieldOffsetsList);
+this.childOffsets = toLongArray(childOffsetsList);
-this.nodeArrayFieldClasses = nodeArrayFieldClassesList.toArray(new Class[nodeArrayFieldClassesList.size()]);
+this.childrenOffsets = toLongArray(childrenOffsetsList);
-this.nodeDataFieldOffsets = toLongArray(nodeDataFieldOffsetList);
+}
-this.nodeDataFieldClasses = nodeDataFieldClassList.toArray(new Class<?>[nodeDataFieldClassList.size()]);
+public NodeField[] getFields() {
-this.parentOffset = parentOffsetTemp;
+return fields;
 }
 public long getParentOffset() {
 return parentOffset;
 }
-public long[] getNodeFieldOffsets() {
+public long[] getChildOffsets() {
-return nodeFieldOffsets;
+return childOffsets;
 }
-public long[] getNodeArrayFieldOffsets() {
+public long[] getChildrenOffsets() {
-return nodeArrayFieldOffsets;
+return childrenOffsets;
 }
 }
-public static class NodeIterator implements Iterator<Node> {
+static class NodeIterator implements Iterator<Node> {
 private final Node node;
 private final NodeClass nodeClass;
 private final int childrenCount;
 private int index;
-public NodeIterator(Node node) {
+protected NodeIterator(Node node) {
-this(node, 0);
-}
-public NodeIterator(Node node, int index) {
 this.node = node;
-this.index = index;
+this.index = 0;
 this.nodeClass = NodeClass.get(node.getClass());
 this.childrenCount = childrenCount();
 }
 private int childrenCount() {
-int nodeCount = nodeClass.nodeFieldOffsets.length;
+int nodeCount = nodeClass.childOffsets.length;
-for (long fieldOffset : nodeClass.nodeArrayFieldOffsets) {
+for (long fieldOffset : nodeClass.childrenOffsets) {
 Node[] children = ((Node[]) unsafe.getObject(node, fieldOffset));
 if (children != null) {
 nodeCount += children.length;
 }
 }
 return nodeCount;
 }
 private Node nodeAt(int idx) {
-int nodeCount = nodeClass.nodeFieldOffsets.length;
+int nodeCount = nodeClass.childOffsets.length;
 if (idx < nodeCount) {
-return (Node) unsafe.getObject(node, nodeClass.nodeFieldOffsets[idx]);
+return (Node) unsafe.getObject(node, nodeClass.childOffsets[idx]);
 } else {
-for (long fieldOffset : nodeClass.nodeArrayFieldOffsets) {
+for (long fieldOffset : nodeClass.childrenOffsets) {
 Node[] nodeArray = (Node[]) unsafe.getObject(node, fieldOffset);
 if (idx < nodeCount + nodeArray.length) {
 return nodeArray[idx - nodeCount];
 }
 nodeCount += nodeArray.length;
 return null;
 }
 unsafe.putObject(clone, nodeClass.parentOffset, null);
-for (long fieldOffset : nodeClass.nodeFieldOffsets) {
+for (long fieldOffset : nodeClass.childOffsets) {
 Node child = (Node) unsafe.getObject(orig, fieldOffset);
 if (child != null) {
 Node clonedChild = cloneNode(child);
 if (clonedChild == null) {
 return null;
 unsafe.putObject(clonedChild, nodeClass.parentOffset, clone);
 unsafe.putObject(clone, fieldOffset, clonedChild);
 }
 }
-for (long fieldOffset : nodeClass.nodeArrayFieldOffsets) {
+for (long fieldOffset : nodeClass.childrenOffsets) {
 Node[] children = (Node[]) unsafe.getObject(orig, fieldOffset);
 if (children != null) {
 Node[] clonedChildren = children.clone();
 Arrays.fill(clonedChildren, null);
 for (int i = 0; i < children.length; i++) {
 public static List<Node> findNodeChildren(Node node) {
 List<Node> nodes = new ArrayList<>();
 NodeClass nodeClass = NodeClass.get(node.getClass());
-for (long fieldOffset : nodeClass.nodeFieldOffsets) {
+for (long fieldOffset : nodeClass.childOffsets) {
 Object child = unsafe.getObject(node, fieldOffset);
 if (child != null) {
 nodes.add((Node) child);
 }
 }
-for (long fieldOffset : nodeClass.nodeArrayFieldOffsets) {
+for (long fieldOffset : nodeClass.childrenOffsets) {
 Node[] children = (Node[]) unsafe.getObject(node, fieldOffset);
 if (children != null) {
 nodes.addAll(Arrays.asList(children));
 }
 }
 }
 public static void replaceChild(Node parent, Node oldChild, Node newChild) {
 NodeClass nodeClass = NodeClass.get(parent.getClass());
-for (long fieldOffset : nodeClass.nodeFieldOffsets) {
+for (long fieldOffset : nodeClass.childOffsets) {
 if (unsafe.getObject(parent, fieldOffset) == oldChild) {
 unsafe.putObject(parent, fieldOffset, newChild);
 }
 }
-for (long fieldOffset : nodeClass.nodeArrayFieldOffsets) {
+for (long fieldOffset : nodeClass.childrenOffsets) {
 Node[] array = (Node[]) unsafe.getObject(parent, fieldOffset);
 if (array != null) {
 for (int i = 0; i < array.length; i++) {
 if (array[i] == oldChild) {
 array[i] = newChild;
 }
 }
 }
 }
-public static long[] getNodeDataFieldOffsets(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return Arrays.copyOf(clazz.nodeDataFieldOffsets, clazz.nodeDataFieldClasses.length);
-}
-public static Class[] getNodeDataFieldClasses(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return Arrays.copyOf(clazz.nodeDataFieldClasses, clazz.nodeDataFieldClasses.length);
-}
-public static long getNodeParentOffset(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return clazz.parentOffset;
-}
-/** Returns the number of Node field declarations in the class hierarchy. */
-public static long[] getNodeFieldOffsets(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return Arrays.copyOf(clazz.nodeFieldOffsets, clazz.nodeFieldOffsets.length);
-}
-/** Returns the number of Node[] declaration in the class hierarchy. */
-public static long[] getNodeFieldArrayOffsets(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return Arrays.copyOf(clazz.nodeArrayFieldOffsets, clazz.nodeArrayFieldOffsets.length);
-}
-public static Class[] getNodeFieldArrayClasses(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return Arrays.copyOf(clazz.nodeArrayFieldClasses, clazz.nodeArrayFieldClasses.length);
-}
-public static Class getNodeParentClass(Class<?> nodeClass) {
-return NodeClass.get(nodeClass).parentClass;
-}
-public static Class[] getNodeFieldClasses(Class<?> nodeClass) {
-NodeClass clazz = NodeClass.get(nodeClass);
-return Arrays.copyOf(clazz.nodeFieldClasses, clazz.nodeFieldClasses.length);
-}
 /** Returns all declared fields in the class hierarchy. */
-public static Field[] getAllFields(Class<? extends Object> clazz) {
+private static Field[] getAllFields(Class<? extends Object> clazz) {
 Field[] declaredFields = clazz.getDeclaredFields();
 if (clazz.getSuperclass() != null) {
 return concat(getAllFields(clazz.getSuperclass()), declaredFields);
 }
 return declaredFields;
 }
 });
 return nodeList;
 }
-public static String printTreeToString(Node node) {
+public static String printCompactTreeToString(Node node) {
-return printTreeToString(node, false);
+StringWriter out = new StringWriter();
-}
+printCompactTree(new PrintWriter(out), null, node, 1);
+return out.toString();
-private static String printTreeToString(Node node, boolean compact) {
+}
-ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
-if (compact) {
+public static void printCompactTree(OutputStream out, Node node) {
-printCompactTree(new PrintStream(byteOut), node);
+printCompactTree(new PrintWriter(out), null, node, 1);
+}
+private static void printCompactTree(PrintWriter p, Node parent, Node node, int level) {
+if (node == null) {
+return;
+}
+for (int i = 0; i < level; i++) {
+p.print("  ");
+}
+if (parent == null) {
+p.println(node.getClass().getSimpleName());
 } else {
-printTree(new PrintStream(byteOut), node);
+String fieldName = "unknownField";
-}
+NodeField[] fields = NodeClass.get(parent.getClass()).fields;
-try {
+for (NodeField field : fields) {
-byteOut.flush();
+Object value = field.loadValue(parent);
-} catch (IOException e) {
+if (value == node) {
-}
+fieldName = field.getName();
-return new String(byteOut.toByteArray());
+break;
+} else if (value instanceof Node[]) {
+int index = 0;
+for (Node arrayNode : (Node[]) value) {
+if (arrayNode == node) {
+fieldName = field.getName() + "[" + index + "]";
+break;
+}
+index++;
+}
+}
+}
+p.print(fieldName);
+p.print(" = ");
+p.println(node.getClass().getSimpleName());
+}
+for (Node child : node.getChildren()) {
+printCompactTree(p, node, child, level + 1);
+}
+p.flush();
 }
 /**
 * Prints a human readable form of a {@link Node} AST to the given {@link PrintStream}. This
 * print method does not check for cycles in the node structure.
 *
-* @param p the {@link PrintStream} to print to.
+* @param out the stream to print to.
 * @param node the root node to write
 */
-public static void printTree(PrintStream p, Node node) {
+public static void printTree(OutputStream out, Node node) {
-printTree(p, node, new NodeTreeResolver());
+printTree(new PrintWriter(out), node);
 }
-public static String printCompactTreeToString(Node node) {
+public static String printTreeToString(Node node) {
-return printTreeToString(node, true);
+StringWriter out = new StringWriter();
-}
+printTree(new PrintWriter(out), node);
+return out.toString();
-public static void printCompactTree(PrintStream p, Node node) {
+}
-printCompactTree(p, null, node, 1);
-}
+public static void printTree(PrintWriter p, Node node) {
+printTree(p, node, 1);
-private static void printCompactTree(PrintStream p, Node parent, Node node, int level) {
-if (node == null) {
-return;
-}
-for (int i = 0; i < level; i++) {
-p.print("  ");
-}
-if (parent == null) {
-p.println(node.getClass().getSimpleName());
-} else {
-String fieldName = null;
-Field[] fields = NodeUtil.getAllFields(parent.getClass());
-try {
-for (Field field : fields) {
-field.setAccessible(true);
-Object value = field.get(parent);
-if (value == node) {
-fieldName = field.getName();
-break;
-} else if (value instanceof Node[]) {
-int index = 0;
-for (Node arrayNode : (Node[]) value) {
-if (arrayNode == node) {
-fieldName = field.getName() + "[" + index + "]";
-break;
-}
-index++;
-}
-}
-}
-} catch (Exception e) {
-e.printStackTrace();
-}
-if (fieldName == null) {
-fieldName = "unknownField";
-}
-p.print(fieldName);
-p.print(" = ");
-p.println(node.getClass().getSimpleName());
-}
-for (Node child : node.getChildren()) {
-printCompactTree(p, node, child, level + 1);
-}
-}
-/**
-* Prints a human readable form of a tree to the given {@link PrintStream}. The
-* {@link TreeResolver} interface needs to be implemented to specify how the method can read the
-* tree from plain a object.
-*
-* @param p the {@link PrintStream} to print to.
-* @param o the root object to be printed.
-* @param resolver an implementation of a tree resolver
-*/
-public static void printTree(PrintStream p, Object o, TreeResolver resolver) {
-printTree(p, o, resolver, 1);
 p.println();
-}
+p.flush();
+}
-private static void printTree(PrintStream p, Object node, TreeResolver resolver, int level) {
+private static void printTree(PrintWriter p, Node node, int level) {
 if (node == null) {
 p.print("null");
 return;
 }
 p.print(node.getClass().getSimpleName());
-Field[] fields = NodeUtil.getAllFields(node.getClass());
+ArrayList<NodeField> childFields = new ArrayList<>();
+String sep = "";
 p.print("(");
+for (NodeField field : NodeClass.get(node.getClass()).fields) {
-ArrayList<Field> childFields = new ArrayList<>();
+if (field.getKind() == NodeFieldKind.CHILD || field.getKind() == NodeFieldKind.CHILDREN) {
-boolean first = true;
-for (int i = 0; i < fields.length; i++) {
-Field field = fields[i];
-if (Modifier.isStatic(field.getModifiers()) || resolver.isFiltered(field)) {
-continue;
-}
-if (resolver.isChildObject(field) || resolver.isChildArrayObject(field)) {
 childFields.add(field);
-}
+} else if (field.getKind() == NodeFieldKind.DATA) {
-if (!resolver.isDataField(field)) {
+p.print(sep);
-continue;
+sep = ", ";
-}
-if (!first) {
+p.print(field.getName());
-p.print(", ");
+p.print(" = ");
-} else {
+p.print(field.loadValue(node));
-first = false;
+}
-}
-Object value = getObjectValue(node, field.getType(), unsafe.objectFieldOffset(field));
-p.print(field.getName());
-p.print(" = ");
-p.print(resolver.toString(value));
 }
 p.print(")");
 if (childFields.size() != 0) {
 p.print(" {");
-}
+for (NodeField field : childFields) {
+printNewLine(p, level);
-// I refetch the fields to get declaration order.
+p.print(field.getName());
-for (int i = 0; i < childFields.size(); i++) {
-Field field = childFields.get(i);
+Object value = field.loadValue(node);
-Class<?> fieldClass = field.getType();
+if (value == null) {
-String name = field.getName();
+p.print(" = null ");
+} else if (field.getKind() == NodeFieldKind.CHILD) {
-long offset = unsafe.objectFieldOffset(field);
+p.print(" = ");
+printTree(p, (Node) value, level + 1);
-Object value = getObjectValue(node, fieldClass, offset);
+} else if (field.getKind() == NodeFieldKind.CHILDREN) {
+Node[] children = (Node[]) value;
-printNewLine(p, level);
-p.print(name);
-if (value == null) {
-p.print(" = null ");
-} else if (resolver.isChildObject(field)) {
-p.print(" = ");
-printTree(p, value, resolver, level + 1);
-} else if (resolver.isChildArrayObject(field)) {
-Object[] objectArray = resolver.convertToArray(field, value);
-if (objectArray.length == 0) {
-p.print(" = []");
-} else {
 p.print(" = [");
-for (int j = 0; j < objectArray.length; j++) {
+sep = "";
-printTree(p, objectArray[j], resolver, level + 1);
+for (Node child : children) {
-if (j < objectArray.length - 1) {
+p.print(sep);
-p.print(", ");
+sep = ", ";
-}
+printTree(p, child, level + 1);
 }
 p.print("]");
 }
-} else {
+}
-assert false;
-}
-}
-if (childFields.size() != 0) {
 printNewLine(p, level - 1);
 p.print("}");
 }
 }
-private static Object getObjectValue(Object base, Class<?> fieldClass, long offset) {
+private static void printNewLine(PrintWriter p, int level) {
-if (fieldClass == boolean.class) {
-return unsafe.getBoolean(base, offset);
-} else if (fieldClass == byte.class) {
-return unsafe.getByte(base, offset);
-} else if (fieldClass == short.class) {
-return unsafe.getShort(base, offset);
-} else if (fieldClass == char.class) {
-return unsafe.getChar(base, offset);
-} else if (fieldClass == int.class) {
-return unsafe.getInt(base, offset);
-} else if (fieldClass == long.class) {
-return unsafe.getLong(base, offset);
-} else if (fieldClass == float.class) {
-return unsafe.getFloat(base, offset);
-} else if (fieldClass == double.class) {
-return unsafe.getDouble(base, offset);
-} else {
-return unsafe.getObject(base, offset);
-}
-}
-private static void printNewLine(PrintStream p, int level) {
 p.println();
 for (int i = 0; i < level; i++) {
 p.print("    ");
 }
 }
-private static class NodeTreeResolver implements TreeResolver {
-@Override
-public boolean isFiltered(Field f) {
-if (f.getName().equals("parent")) {
-return true;
-}
-return f.isSynthetic();
-}
-@Override
-public boolean isDataField(Field f) {
-return !isChildArrayObject(f) && !isChildObject(f);
-}
-@Override
-public boolean isChildObject(Field f) {
-return Node.class.isAssignableFrom(f.getType()) && f.getAnnotation(Child.class) != null;
-}
-@Override
-public boolean isChildArrayObject(Field f) {
-return f.getType().getComponentType() != null && Node.class.isAssignableFrom(f.getType().getComponentType()) && f.getAnnotation(Children.class) != null;
-}
-@Override
-public Object[] convertToArray(Field f, Object data) {
-return (Object[]) data;
-}
-@Override
-public String toString(Object o) {
-return o == null ? "null" : o.toString();
-}
-}
-/**
-* Specifies how a tree can be built from plain objects.
-*/
-public interface TreeResolver {
-/**
-* Returns true if a {@link Field} is filtered from the tree.
-*
-* @param f the field to check
-*/
-boolean isFiltered(Field f);
-/**
-* Returns true if a {@link Field} is a field that contains a data value which should not be
-* traversed recursively.
-*
-* @param f the field to check
-* @return true if a the given field is a data field else false.
-*/
-boolean isDataField(Field f);
-/**
-* Returns true if a {@link Field} is a field that contains an {@link Object} which should
-* be recursively visited.
-*
-* @param f the field to check
-* @return true if a the given field is a child field else false.
-*/
-boolean isChildObject(Field f);
-/**
-* Returns true if a {@link Field} is a field that contains any kind of list/array structure
-* which itself holds values that should be recursively visited.
-*
-* @param f the field to check
-* @return true if a the given field is a child array/list field else false.
-*/
-boolean isChildArrayObject(Field f);
-/**
-* Converts an given child array object to array which can be traversed. This is especially
-* useful to convert any kind of list structure to a traversable array.
-*
-* @param f the field for meta data needed to convert the data {@link Object}.
-* @param value the actual value of the child array/list object.
-* @return the converted {@link Object} array.
-*/
-Object[] convertToArray(Field f, Object value);
-/**
-* Returns a human readable string for any data field object in the tree.
-*
-* @param o the object to convert to string.
-* @return the converted string
-*/
-String toString(Object o);
-}
 }

Mercurial > hg > truffle

comparison graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java @ 9754:98b004bf3985