plugins/org.eclipse.mat.parser/src/org/eclipse/mat/parser/internal/oql/compiler/PathExpression.java - mat/org.eclipse.mat - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2020 SAP AG and IBM Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    SAP AG - initial API and implementation
  *    Andrew Johnson - array indexing and wrapping
  *******************************************************************************/
 package org.eclipse.mat.parser.internal.oql.compiler;

 import java.beans.BeanInfo;
 import java.beans.Introspector;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Array;
 import java.lang.reflect.Method;
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.mat.SnapshotException;
 import org.eclipse.mat.parser.internal.Messages;
 import org.eclipse.mat.snapshot.model.Field;
 import org.eclipse.mat.snapshot.model.FieldDescriptor;
 import org.eclipse.mat.snapshot.model.IClass;
 import org.eclipse.mat.snapshot.model.IObject;
 import org.eclipse.mat.util.MessageUtil;

 class PathExpression extends Expression
 {
     private static class ArrayWrapper extends AbstractList<Object> {
         private final Object element;
         public ArrayWrapper(Object element) {
             this.element = element;
         }
         @Override
         public Object get(int i)
         {
             return Array.get(element, i);
         }

         @Override
         public int size()
         {
             return Array.getLength(element);
         }

         /*
          * Could override toString as but it can be useful to see the contents
          * element.getClass().getComponentType().getSimpleName()+'['+size()+']';
          */
     };

     private List<Object> attributes;

     public PathExpression(List<Object> attributes)
     {
         this.attributes = attributes;
     }

     @Override
     public Object compute(EvaluationContext ctx) throws SnapshotException
     {
         try
         {
             Object current = null;
             int index = 0;

             // check for alias
             Object firstItem = attributes.get(0);
             if (firstItem instanceof Attribute)
             {
                 Attribute firstAttribute = (Attribute) firstItem;
                 current = !firstAttribute.isNative() ? ctx.getAlias(firstAttribute.getName()) : null;
                 if (current != null || !firstAttribute.isNative() && ctx.isAlias(firstAttribute.getName()))
                 {
                     // We retrieved an alias (or snapshot) from the attribute, even if it was null, so advance
                     index++;
                 }
             }

             if (index == 0)
                 current = ctx.getSubject();

             for (; index < this.attributes.size(); index++)
             {
                 if (current == null)
                     break;
                 Object element = this.attributes.get(index);

                 if (element != null && element.getClass().isArray())
                     element = asList(element);

                 if (element instanceof Attribute)
                 {
                     Attribute attribute = (Attribute) element;
                     if (attribute.isNative() || !(current instanceof IObject))
                     {
                         // special: we support the 'length' property for arrays
                         if (current.getClass().isArray())
                         {
                             if ("length".equals(attribute.getName())) //$NON-NLS-1$
                             {
                                 current = Array.getLength(current);
                             }
                             else
                             {
                                 throw new SnapshotException(MessageUtil.format(
                                                 Messages.PathExpression_Error_ArrayHasNoProperty, new Object[] {
                                                                 current.getClass().getComponentType().getName(),
                                                                 attribute.name }));
                             }
                         }
                         else
                         {
                             boolean didFindProperty = false;

                             if (!attribute.isNative())
                             {
                                 // Used for table rows from sub-select
                                 if (current instanceof  Map<?,?>)
                                 {
                                     Map<?,?> map = (Map<?,?>)current;
                                     current = map.get(attribute.getName());
                                     didFindProperty = true;
                                 }
                             }

                             if (!didFindProperty)
                             {
                                 BeanInfo info = Introspector.getBeanInfo(current.getClass());
                                 PropertyDescriptor[] descriptors = info.getPropertyDescriptors();

                                 for (PropertyDescriptor descriptor : descriptors)
                                 {
                                     if (attribute.getName().equals(descriptor.getName()))
                                     {
                                         Method method = descriptor.getReadMethod();
                                         // Perhaps the method should be accessible via an interface, so try that first
                                         boolean useInterface = false;
                                         for (Class<?> intf : method.getDeclaringClass().getInterfaces())
                                         {
                                             try
                                             {
                                                 // Avoid some NoSuchMethodExceptions by checking the name and number of parms first
                                                 for (Method m3 : intf.getMethods())
                                                 {
                                                     if (!m3.getName().equals(method.getName()))
                                                         continue;
                                                     if (m3.getParameterCount() != method.getParameterTypes().length)
                                                         continue;
                                                     Method m2 = intf.getMethod(method.getName(), method.getParameterTypes());
                                                     MethodCallExpression.checkMethodAccess(m2);
                                                     // Switching to the interface method
                                                     method = m2;
                                                     // Indicate found
                                                     useInterface = true;
                                                     break;
                                                 }
                                             }
                                             catch (NoSuchMethodException e1)
                                             {
                                             }
                                             catch (SecurityException e1)
                                             {
                                             }
                                             if (useInterface)
                                                 break;
                                         }
                                         if (!useInterface)
                                         {
                                             try
                                             {
                                                 // Check whether access to this method should be allowed
                                                 MethodCallExpression.checkMethodAccess(method);
                                             }
                                             catch (SecurityException e)
                                             {
                                                 // Fail for the original reason
                                                 throw new SnapshotException(MessageUtil.format(
                                                                 Messages.PathExpression_Error_TypeHasNoProperty,
                                                                 new Object[] { current.getClass().getName(),
                                                                                 attribute.name }),
                                                                 e);
                                             }
                                         }
                                         current = method.invoke(current, (Object[]) null);
                                         didFindProperty = true;
                                         break;
                                     }
                                 }
                             }

                             if (!didFindProperty) { throw new SnapshotException(MessageUtil.format(
                                             Messages.PathExpression_Error_TypeHasNoProperty, new Object[] {
                                                             current.getClass().getName(), attribute.name })); }
                         }

                     }
                     else
                     {
                         IObject c = (IObject) current;
                         // Performance optimization - check that the field exists first
                         boolean found = false;
                         field: for (IClass cls = c.getClazz(); cls != null; cls = cls.getSuperClass())
                         {
                             for (FieldDescriptor fd : cls.getFieldDescriptors())
                             {
                                 if (fd.getName().equals(attribute.getName()))
                                 {
                                     found = true;
                                     break field;
                                 }
                             }
                         }
                         if (found)
                         {
                             current = c.resolveValue(attribute.getName());
                         }
                         else
                         {
                             if (current instanceof IClass)
                             {
                                 field: for (IClass cls = (IClass)current; cls != null; cls = cls.getSuperClass())
                                 {
                                     for (Field f : cls.getStaticFields()) {
                                         if (f.getName().equals(attribute.getName())) {
                                             current = f.getValue();
                                             found = true;
                                             break field;
                                         }
                                     }
                                 }
                             }
                             if (!found)
                             {
                                 current = null;
                             }
                         }
                     }
                 }
                 else if (element instanceof Expression)
                 {
                     EvaluationContext methodCtx = new EvaluationContext(ctx);
                     methodCtx.setSubject(current);
                     current = ((Expression) element).compute(methodCtx);
                 }
                 else
                 {
                     throw new SnapshotException(MessageUtil.format(Messages.PathExpression_Error_UnknownElementInPath,
                                     new Object[] { element }));
                 }

                 if (current == null)
                     break;
             }

             return current;
         }
         catch (Exception e)
         {
             throw SnapshotException.rethrow(e);
         }
     }

     protected static List<?> asList(final Object element)
     {
         int size = Array.getLength(element);
         final boolean wrap = true;
         List<Object> answer;

         if (wrap)
         {
             // Wrap the original array
             answer = new ArrayWrapper(element);
         }
         else
         {
             // Make a copy of the array
             answer = new ArrayList<Object>(size);
             for (int ii = 0; ii < size; ii++)
                 answer.add(Array.get(element, ii));
         }

         return answer;
     }

     @Override
     public boolean isContextDependent(EvaluationContext ctx)
     {
         Object firstItem = attributes.get(0);
         if (firstItem instanceof Attribute)
         {
             Attribute firstAttribute = (Attribute) firstItem;
             if (!firstAttribute.isNative() && ctx.isAlias(firstAttribute.getName()))
                 return true;
         }
         else if (firstItem instanceof Expression)
         {
             if (((Expression) firstItem).isContextDependent(ctx))
                 return true;
         }
         for (int i = 1; i < attributes.size(); ++i)
         {
             Object nextItem = attributes.get(i);
             if (nextItem instanceof Expression)
                 if (((Expression) nextItem).isContextDependent(ctx))
                     return true;
         }
         return false;
     }

     @Override
     public String toString()
     {
         StringBuilder buf = new StringBuilder(256);

         boolean first = true;
         for (Iterator<Object> iter = this.attributes.iterator(); iter.hasNext();)
         {
             Object element = iter.next();
             if (!first && !(element instanceof ArrayIndexExpression))
                 buf.append(".");//$NON-NLS-1$
             first = false;
             buf.append(element);
         }

         return buf.toString();
     }

 }
	/*******************************************************************************
	* Copyright (c) 2008, 2020 SAP AG and IBM Corporation.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* SAP AG - initial API and implementation
	* Andrew Johnson - array indexing and wrapping
	*******************************************************************************/
	package org.eclipse.mat.parser.internal.oql.compiler;

	import java.beans.BeanInfo;
	import java.beans.Introspector;
	import java.beans.PropertyDescriptor;
	import java.lang.reflect.Array;
	import java.lang.reflect.Method;
	import java.util.AbstractList;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.mat.SnapshotException;
	import org.eclipse.mat.parser.internal.Messages;
	import org.eclipse.mat.snapshot.model.Field;
	import org.eclipse.mat.snapshot.model.FieldDescriptor;
	import org.eclipse.mat.snapshot.model.IClass;
	import org.eclipse.mat.snapshot.model.IObject;
	import org.eclipse.mat.util.MessageUtil;

	class PathExpression extends Expression
	{
	private static class ArrayWrapper extends AbstractList<Object> {
	private final Object element;
	public ArrayWrapper(Object element) {
	this.element = element;
	}
	@Override
	public Object get(int i)
	{
	return Array.get(element, i);
	}

	@Override
	public int size()
	{
	return Array.getLength(element);
	}

	/*
	* Could override toString as but it can be useful to see the contents
	* element.getClass().getComponentType().getSimpleName()+'['+size()+']';
	*/
	};

	private List<Object> attributes;

	public PathExpression(List<Object> attributes)
	{
	this.attributes = attributes;
	}

	@Override
	public Object compute(EvaluationContext ctx) throws SnapshotException
	{
	try
	{
	Object current = null;
	int index = 0;

	// check for alias
	Object firstItem = attributes.get(0);
	if (firstItem instanceof Attribute)
	{
	Attribute firstAttribute = (Attribute) firstItem;
	current = !firstAttribute.isNative() ? ctx.getAlias(firstAttribute.getName()) : null;
	if (current != null \|\| !firstAttribute.isNative() && ctx.isAlias(firstAttribute.getName()))
	{
	// We retrieved an alias (or snapshot) from the attribute, even if it was null, so advance
	index++;
	}
	}

	if (index == 0)
	current = ctx.getSubject();

	for (; index < this.attributes.size(); index++)
	{
	if (current == null)
	break;
	Object element = this.attributes.get(index);

	if (element != null && element.getClass().isArray())
	element = asList(element);

	if (element instanceof Attribute)
	{
	Attribute attribute = (Attribute) element;
	if (attribute.isNative() \|\| !(current instanceof IObject))
	{
	// special: we support the 'length' property for arrays
	if (current.getClass().isArray())
	{
	if ("length".equals(attribute.getName())) //$NON-NLS-1$
	{
	current = Array.getLength(current);
	}
	else
	{
	throw new SnapshotException(MessageUtil.format(
	Messages.PathExpression_Error_ArrayHasNoProperty, new Object[] {
	current.getClass().getComponentType().getName(),
	attribute.name }));
	}
	}
	else
	{
	boolean didFindProperty = false;

	if (!attribute.isNative())
	{
	// Used for table rows from sub-select
	if (current instanceof Map<?,?>)
	{
	Map<?,?> map = (Map<?,?>)current;
	current = map.get(attribute.getName());
	didFindProperty = true;
	}
	}

	if (!didFindProperty)
	{
	BeanInfo info = Introspector.getBeanInfo(current.getClass());
	PropertyDescriptor[] descriptors = info.getPropertyDescriptors();

	for (PropertyDescriptor descriptor : descriptors)
	{
	if (attribute.getName().equals(descriptor.getName()))
	{
	Method method = descriptor.getReadMethod();
	// Perhaps the method should be accessible via an interface, so try that first
	boolean useInterface = false;
	for (Class<?> intf : method.getDeclaringClass().getInterfaces())
	{
	try
	{
	// Avoid some NoSuchMethodExceptions by checking the name and number of parms first
	for (Method m3 : intf.getMethods())
	{
	if (!m3.getName().equals(method.getName()))
	continue;
	if (m3.getParameterCount() != method.getParameterTypes().length)
	continue;
	Method m2 = intf.getMethod(method.getName(), method.getParameterTypes());
	MethodCallExpression.checkMethodAccess(m2);
	// Switching to the interface method
	method = m2;
	// Indicate found
	useInterface = true;
	break;
	}
	}
	catch (NoSuchMethodException e1)
	{
	}
	catch (SecurityException e1)
	{
	}
	if (useInterface)
	break;
	}
	if (!useInterface)
	{
	try
	{
	// Check whether access to this method should be allowed
	MethodCallExpression.checkMethodAccess(method);
	}
	catch (SecurityException e)
	{
	// Fail for the original reason
	throw new SnapshotException(MessageUtil.format(
	Messages.PathExpression_Error_TypeHasNoProperty,
	new Object[] { current.getClass().getName(),
	attribute.name }),
	e);
	}
	}
	current = method.invoke(current, (Object[]) null);
	didFindProperty = true;
	break;
	}
	}
	}

	if (!didFindProperty) { throw new SnapshotException(MessageUtil.format(
	Messages.PathExpression_Error_TypeHasNoProperty, new Object[] {
	current.getClass().getName(), attribute.name })); }
	}

	}
	else
	{
	IObject c = (IObject) current;
	// Performance optimization - check that the field exists first
	boolean found = false;
	field: for (IClass cls = c.getClazz(); cls != null; cls = cls.getSuperClass())
	{
	for (FieldDescriptor fd : cls.getFieldDescriptors())
	{
	if (fd.getName().equals(attribute.getName()))
	{
	found = true;
	break field;
	}
	}
	}
	if (found)
	{
	current = c.resolveValue(attribute.getName());
	}
	else
	{
	if (current instanceof IClass)
	{
	field: for (IClass cls = (IClass)current; cls != null; cls = cls.getSuperClass())
	{
	for (Field f : cls.getStaticFields()) {
	if (f.getName().equals(attribute.getName())) {
	current = f.getValue();
	found = true;
	break field;
	}
	}
	}
	}
	if (!found)
	{
	current = null;
	}
	}
	}
	}
	else if (element instanceof Expression)
	{
	EvaluationContext methodCtx = new EvaluationContext(ctx);
	methodCtx.setSubject(current);
	current = ((Expression) element).compute(methodCtx);
	}
	else
	{
	throw new SnapshotException(MessageUtil.format(Messages.PathExpression_Error_UnknownElementInPath,
	new Object[] { element }));
	}

	if (current == null)
	break;
	}

	return current;
	}
	catch (Exception e)
	{
	throw SnapshotException.rethrow(e);
	}
	}

	protected static List<?> asList(final Object element)
	{
	int size = Array.getLength(element);
	final boolean wrap = true;
	List<Object> answer;

	if (wrap)
	{
	// Wrap the original array
	answer = new ArrayWrapper(element);
	}
	else
	{
	// Make a copy of the array
	answer = new ArrayList<Object>(size);
	for (int ii = 0; ii < size; ii++)
	answer.add(Array.get(element, ii));
	}

	return answer;
	}

	@Override
	public boolean isContextDependent(EvaluationContext ctx)
	{
	Object firstItem = attributes.get(0);
	if (firstItem instanceof Attribute)
	{
	Attribute firstAttribute = (Attribute) firstItem;
	if (!firstAttribute.isNative() && ctx.isAlias(firstAttribute.getName()))
	return true;
	}
	else if (firstItem instanceof Expression)
	{
	if (((Expression) firstItem).isContextDependent(ctx))
	return true;
	}
	for (int i = 1; i < attributes.size(); ++i)
	{
	Object nextItem = attributes.get(i);
	if (nextItem instanceof Expression)
	if (((Expression) nextItem).isContextDependent(ctx))
	return true;
	}
	return false;
	}

	@Override
	public String toString()
	{
	StringBuilder buf = new StringBuilder(256);

	boolean first = true;
	for (Iterator<Object> iter = this.attributes.iterator(); iter.hasNext();)
	{
	Object element = iter.next();
	if (!first && !(element instanceof ArrayIndexExpression))
	buf.append(".");//$NON-NLS-1$
	first = false;
	buf.append(element);
	}

	return buf.toString();
	}

	}