package com.onpositive.gae.profiler.ui;
import java.io.IOException;
import java.io.InputStream;
import java.text.NumberFormat;
import java.util.Comparator;
import java.util.WeakHashMap;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.ITypeHierarchy;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.TableLayout;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Spinner;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.widgets.FormText;
import org.eclipse.ui.forms.widgets.ImageHyperlink;
import org.eclipse.ui.forms.widgets.Section;
import org.eclipse.ui.part.PageBook;
import org.eclipse.ui.texteditor.IDocumentProvider;
import org.eclipse.ui.texteditor.ITextEditor;
import com.onpositive.commons.ui.viewers.AbstractViewerEditorPart;
import com.onpositive.commons.ui.viewers.ConfigurableViewer;
import com.onpositive.commons.ui.viewers.FilterMode;
import com.onpositive.commons.ui.viewers.IFilter;
import com.onpositive.commons.ui.viewers.TableSortController;
import com.onpositive.commons.ui.viewers.ViewerConfiguration;
import com.onpositive.gae.profiler.Activator;
import com.onpositive.gae.profiler.ITrace;
import com.onpositive.gae.profiler.SnapshotFilter;
import com.onpositive.gae.profiler.core.AccumulatedMethod;
import com.onpositive.gae.profiler.core.Snapshot;
import com.onpositive.gae.profiling.rpc.MemCacheStorageAttachment;
import com.onpositive.gae.profiling.rpc.DataStoreCallStorageAttachment.GetRequestInfo;
import com.onpositive.gae.profiling.rpc.DataStoreCallStorageAttachment.PutRequestInfo;
import com.onpositive.gae.profiling.rpc.MemCacheStorageAttachment.GetFromMemcacheRequestInfo;
import com.onpositive.gae.profiling.rpc.RPCAttachment.RequestInfo;
import com.onpositive.gae.tools.core.LogViewPart.MM;
import com.onpositive.gae.tools.license.LicenseChecker;
public class SnapshotDataViewer extends AbstractViewerEditorPart {
ViewerConfigurationFactories fact;
private Spinner limitSpinner;
private Text patternText;
private Combo filterMode;
boolean refilter;
private ComboViewer items;
private Label filterLabel;
static Image stackImage = Activator.imageDescriptorFromPlugin(
Activator.PLUGIN_ID, "icons/stackframe.gif").createImage();
public SnapshotDataViewer() {
super(Activator.PLUGIN_ID);
}
public void doSave(IProgressMonitor monitor) {
}
public void doSaveAs() {
}
Snapshot data = null;
public void init(IEditorSite site, IEditorInput input)
throws PartInitException {
super.setSite(site);
super.setInput(input);
if (input instanceof IFileEditorInput) {
IFileEditorInput fl = (IFileEditorInput) input;
try {
IFile file = fl.getFile();
InputStream stream = file.getContents(true);
try {
data = new Snapshot(stream);
fact = new ViewerConfigurationFactories(data);
} catch (Exception e) {
Activator.getDefault().log(e);
} finally {
try {
stream.close();
} catch (IOException e) {
Activator.getDefault().log(e);
}
}
} catch (CoreException e) {
Activator.getDefault().log(e);
}
}
setPartName(input.getName());
}
public boolean isDirty() {
return false;
}
public boolean isSaveAsAllowed() {
return false;
}
public void createPartControl(Composite parent) {
LicenseChecker.checkLicense(true);
super.createPartControl(parent);
}
public void setFocus() {
}
private final class MT extends LabelProvider implements ITableLabelProvider {
public Image getColumnImage(Object element, int columnIndex) {
if (columnIndex==0){
return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_DEF_VIEW);
}
return null;
}
public String getColumnText(Object element, int columnIndex) {
RequestInfo r = (RequestInfo) element;
if (columnIndex == 0) {
return getReqestMessage(r);
}
if (columnIndex == 1) {
return "" + r.getCount();
}
if (element instanceof MemCacheStorageAttachment.SetRequestInfo) {
return "--";
}
if (element instanceof MemCacheStorageAttachment.GetFromMemcacheRequestInfo) {
MemCacheStorageAttachment.GetFromMemcacheRequestInfo m = (GetFromMemcacheRequestInfo) element;
return NumberFormat.getNumberInstance().format(
((double) m.successes / (double) m.totalCount));
}
if (element instanceof MemCacheStorageAttachment.DeleteFromMemcacheRequestInfo) {
return "--";
}
return NumberFormat.getNumberInstance().format(
((double) r.getCost()) / 1.2);
}
}
public class SelfTimeCalculator implements PercentCalculator<ITrace> {
public double percent(ITrace trace) {
return (trace.getSelfTime() * 100) / data.getTotalValue();
}
}
protected void createAnalisysParts(CTabFolder flt) {
ITrace[] hotSpotsByModule = data.getHotSpotsByModule();
if (hotSpotsByModule != null) {
String title = "Hot spots by package";
createChartSectionPart(hotSpotsByModule, title, flt,
new SelfTimeCalculator(), false);
}
ITrace[] hotSpotsByMethod = data.getHotSpotsByMethod();
if (hotSpotsByMethod != null) {
String title = "Hot spots by method";
createChartSectionPart(hotSpotsByMethod, title, flt,
new SelfTimeCalculator());
}
// ITrace[] allocationHotSpots = snapshot.getAllocationHotSpots();
// if (allocationHotSpots != null) {
// String title = "Allocation hot spots";
// createChartSectionPart(allocationHotSpots, title, flt,
// new MemoryCalculator());
// flt.setSelection(0);
// }
flt.setSelection(0);
}
protected void createControls(Composite parent) {
Composite body = form.getBody();
GridLayout ll2 = new GridLayout(1, false);
body.setLayout(ll2);
ll2.marginWidth = 5;
ll2.marginHeight = 0;
ll2.marginBottom = 4;
form.setText("Method List");
viewer.configure(fact.getMethodListConfiguration());
viewer.setInput(data);
parent.setLayout(new FillLayout());
}
Composite dataStore;
Composite memcache;
protected void createExtraPages(PageBook pageBook2) {
dataStore = formToolkit.createComposite(pageBook2, SWT.NONE);
memcache = formToolkit.createComposite(pageBook2, SWT.NONE);
dataStore.setLayout(new GridLayout(1, false));
formToolkit
.createLabel(dataStore,
"This page represents information about top data store queries:");
memcache.setLayout(new GridLayout(1, false));
formToolkit.createLabel(memcache,
"This page represents information about top memcache queries:");
Composite c = dataStore;
createDataStorePage(c);
createMemcachePage(memcache);
}
private void createMemcachePage(Composite c) {
SashForm f = new SashForm(c, SWT.HORIZONTAL);
f.setLayoutData(GridDataFactory.fillDefaults().grab(true, true)
.create());
TableViewer tv = new TableViewer(f);
TableColumn tableColumn = new TableColumn(tv.getTable(), SWT.LEFT);
tableColumn.setText("Title");
TableColumn countColumn = new TableColumn(tv.getTable(), SWT.LEFT);
countColumn.setText("Count");
TableColumn costColumn = new TableColumn(tv.getTable(), SWT.LEFT);
costColumn.setText("Success rate");
tv.getTable().setHeaderVisible(true);
tv.setLabelProvider(new MT());
tv.getTable().setLinesVisible(true);
tv.setContentProvider(new ArrayContentProvider());
tv.setInput(data.getMemCacheInfo());
TableLayout layout = new TableLayout();
tv.getTable().setLayout(layout);
layout.addColumnData(new ColumnWeightData(4, true));
layout.addColumnData(new ColumnWeightData(1, true));
layout.addColumnData(new ColumnWeightData(1, true));
Composite createComposite = formToolkit.createComposite(f, SWT.NONE);
GridLayout layout2 = new GridLayout(1, false);
layout2.marginHeight = 0;
createComposite.setLayout(layout2);
Section desc = formToolkit.createSection(createComposite,
Section.TITLE_BAR);
desc.setText("Details");
final FormText createFormText = formToolkit.createFormText(desc, false);
createFormText
.setText(
"<form><p>Please select query\n\n\n<br/><br/> <br/></p></form>",
true, false);
desc.setClient(createFormText);
desc.setLayoutData(GridDataFactory.fillDefaults().grab(true, false)
.hint(-1, 200).create());
Section stack = formToolkit.createSection(createComposite,
Section.TITLE_BAR);
stack.setText("Stack");
stack.setLayoutData(GridDataFactory.fillDefaults().grab(true, true)
.create());
final TableViewer tableViewer = new TableViewer(stack);
tableViewer.getTable().setLinesVisible(true);
tableViewer.setContentProvider(new ArrayContentProvider());
tv.addSelectionChangedListener(new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
IStructuredSelection sel = (IStructuredSelection) event
.getSelection();
if (sel.isEmpty()) {
tableViewer.setInput(null);
} else {
RequestInfo info = (RequestInfo) sel.getFirstElement();
tableViewer.setInput(info.getStackTrace());
StringBuilder bld = new StringBuilder();
bld.append("<form>");
bld.append("<p>");
bld.append("<b>Query:</b> " + info.getMessage());
bld.append("<br/>");
bld.append("<b>Count:</b> " + info.getCount());
bld.append("<br/>");
// bld.append("<b>Api time(ms):</b> "+info.getCost());
// if (info instanceof PutRequestInfo){
// PutRequestInfo pr=(PutRequestInfo) info;
// if (pr.entityWritesBytes!=0){
// bld.append("<br/>");
// bld.append("<b>Entity writes:</b> "+pr.entityWrites);
// bld.append(" <b>Entity writes bytes:</b> "+pr.entityWritesBytes);
// bld.append("<br/>");
// bld.append("<b>Index writes:</b> "+pr.indexWrites);
// bld.append(" <b>Index writes bytes:</b> "+pr.indexWriteBytes);
// bld.append("<br/>");
// }
// }
// else if (info instanceof GetRequestInfo){
// GetRequestInfo r=(GetRequestInfo) info;
// bld.append("<br/>");
// bld.append("<b>Entity count:</b> "+r.entityCount);
// bld.append("<br/><b>Result bytes:</b> "+r.resultBytes);
// bld.append("<br/>");
// }
// bld.append("</p>");
bld.append("</p></form>");
createFormText.setText(bld.toString(), true, true);
// createFormText.getParent().getParent().layout(true);
}
}
});
tableViewer.setLabelProvider(new LabelProvider() {
public Image getImage(Object element) {
return stackImage;
}
});
new TableSortController(tv, tableColumn, new Comparator<RequestInfo>() {
public int compare(RequestInfo o1, RequestInfo o2) {
return getReqestMessage(o1).compareTo(getReqestMessage(o2));
}
}, true, true);
new TableSortController(tv, countColumn, new Comparator<RequestInfo>() {
public int compare(RequestInfo o1, RequestInfo o2) {
return o1.getCount() - o2.getCount();
}
}, true, true);
TableSortController tableSortController = new TableSortController(tv,
costColumn, new Comparator<RequestInfo>() {
public int compare(RequestInfo o1, RequestInfo o2) {
if (o1 instanceof MemCacheStorageAttachment.GetFromMemcacheRequestInfo){
if (o2 instanceof MemCacheStorageAttachment.GetFromMemcacheRequestInfo){
MemCacheStorageAttachment.GetFromMemcacheRequestInfo m1=(GetFromMemcacheRequestInfo) o1;
MemCacheStorageAttachment.GetFromMemcacheRequestInfo m2=(GetFromMemcacheRequestInfo) o2;
return (int) ((m1.successes/(double)m1.totalCount)*1000-(m2.successes/(double)m2.totalCount)*1000);
}
}
if (o1 instanceof MemCacheStorageAttachment.GetFromMemcacheRequestInfo){
return -1;
}
if (o2 instanceof MemCacheStorageAttachment.GetFromMemcacheRequestInfo){
return 1;
}
return (int) (o2.getCost() - o1.getCost());
}
}, true, true);
tableSortController.stateChanged();
// tableSortController.stateChanged();
tableViewer.addOpenListener(new IOpenListener() {
public void open(OpenEvent event) {
IStructuredSelection s = (IStructuredSelection) event
.getSelection();
StackTraceElement sm = (StackTraceElement) s.getFirstElement();
doOpenStacktrace(sm);
}
});
tv.addOpenListener(new IOpenListener() {
public void open(OpenEvent event) {
IStructuredSelection s = (IStructuredSelection) event
.getSelection();
RequestInfo sm = (RequestInfo) s.getFirstElement();
if (sm != null) {
doOpenStacktrace(sm.getStackTrace()[0]);
}
}
});
stack.setClient(tableViewer.getTable());
}
private void createDataStorePage(Composite c) {
SashForm f = new SashForm(c, SWT.HORIZONTAL);
f.setLayoutData(GridDataFactory.fillDefaults().grab(true, true)
.create());
TableViewer tv = new TableViewer(f);
TableColumn tableColumn = new TableColumn(tv.getTable(), SWT.LEFT);
tableColumn.setText("Title");
TableColumn countColumn = new TableColumn(tv.getTable(), SWT.LEFT);
countColumn.setText("Count");
TableColumn costColumn = new TableColumn(tv.getTable(), SWT.LEFT);
costColumn.setText("Api time(ms)");
tv.getTable().setHeaderVisible(true);
tv.setLabelProvider(new MT());
tv.getTable().setLinesVisible(true);
tv.setContentProvider(new ArrayContentProvider());
tv.setInput(data.getDataStoreInfo());
TableLayout layout = new TableLayout();
tv.getTable().setLayout(layout);
layout.addColumnData(new ColumnWeightData(4, true));
layout.addColumnData(new ColumnWeightData(1, true));
layout.addColumnData(new ColumnWeightData(1, true));
Composite createComposite = formToolkit.createComposite(f, SWT.NONE);
GridLayout layout2 = new GridLayout(1, false);
layout2.marginHeight = 0;
createComposite.setLayout(layout2);
Section desc = formToolkit.createSection(createComposite,
Section.TITLE_BAR);
desc.setText("Details");
final FormText createFormText = formToolkit.createFormText(desc, false);
createFormText
.setText(
"<form><p>Please select query\n\n\n<br/><br/> <br/></p></form>",
true, false);
desc.setClient(createFormText);
desc.setLayoutData(GridDataFactory.fillDefaults().grab(true, false)
.hint(-1, 200).create());
Section stack = formToolkit.createSection(createComposite,
Section.TITLE_BAR);
stack.setText("Stack");
stack.setLayoutData(GridDataFactory.fillDefaults().grab(true, true)
.create());
final TableViewer tableViewer = new TableViewer(stack);
tableViewer.getTable().setLinesVisible(true);
tableViewer.setContentProvider(new ArrayContentProvider());
tv.addSelectionChangedListener(new ISelectionChangedListener() {
public void selectionChanged(SelectionChangedEvent event) {
IStructuredSelection sel = (IStructuredSelection) event
.getSelection();
if (sel.isEmpty()) {
tableViewer.setInput(null);
} else {
RequestInfo info = (RequestInfo) sel.getFirstElement();
tableViewer.setInput(info.getStackTrace());
StringBuilder bld = new StringBuilder();
bld.append("<form>");
bld.append("<p>");
bld.append("<b>Query:</b> " + info.getMessage());
bld.append("<br/>");
bld.append("<b>Count:</b> " + info.getCount());
bld.append("<br/>");
bld.append("<b>Api time(ms):</b> " + info.getCost());
if (info instanceof PutRequestInfo) {
PutRequestInfo pr = (PutRequestInfo) info;
if (pr.entityWritesBytes != 0) {
bld.append("<br/>");
bld.append("<b>Entity writes:</b> "
+ pr.entityWrites);
bld.append(" <b>Entity writes bytes:</b> "
+ pr.entityWritesBytes);
bld.append("<br/>");
bld
.append("<b>Index writes:</b> "
+ pr.indexWrites);
bld.append(" <b>Index writes bytes:</b> "
+ pr.indexWriteBytes);
bld.append("<br/>");
}
} else if (info instanceof GetRequestInfo) {
GetRequestInfo r = (GetRequestInfo) info;
bld.append("<br/>");
bld.append("<b>Entity count:</b> " + r.entityCount);
bld
.append("<br/><b>Result bytes:</b> "
+ r.resultBytes);
bld.append("<br/>");
}
bld.append("</p>");
bld.append("</form>");
createFormText.setText(bld.toString(), true, true);
// createFormText.getParent().getParent().layout(true);
}
}
});
tableViewer.setLabelProvider(new LabelProvider() {
public Image getImage(Object element) {
return stackImage;
}
});
new TableSortController(tv, tableColumn, new Comparator<RequestInfo>() {
public int compare(RequestInfo o1, RequestInfo o2) {
return getReqestMessage(o1).compareTo(getReqestMessage(o2));
}
}, true, true);
new TableSortController(tv, countColumn, new Comparator<RequestInfo>() {
public int compare(RequestInfo o1, RequestInfo o2) {
return o1.getCount() - o2.getCount();
}
}, true, true);
TableSortController tableSortController = new TableSortController(tv,
costColumn, new Comparator<RequestInfo>() {
public int compare(RequestInfo o1, RequestInfo o2) {
return (int) (o2.getCost() - o1.getCost());
}
}, true, true);
tableSortController.stateChanged();
// tableSortController.stateChanged();
tableViewer.addOpenListener(new IOpenListener() {
public void open(OpenEvent event) {
IStructuredSelection s = (IStructuredSelection) event
.getSelection();
StackTraceElement sm = (StackTraceElement) s.getFirstElement();
doOpenStacktrace(sm);
}
});
tv.addOpenListener(new IOpenListener() {
public void open(OpenEvent event) {
IStructuredSelection s = (IStructuredSelection) event
.getSelection();
RequestInfo sm = (RequestInfo) s.getFirstElement();
if (sm != null) {
doOpenStacktrace(sm.getStackTrace()[0]);
}
}
});
stack.setClient(tableViewer.getTable());
}
public final class ShowDataStoreRunnable implements Runnable {
public void run() {
enableFilters(false);
treeManager.removeAll();
treeManager.update(true);
pageBook.showPage(dataStore);
}
}
public final class ShowMemCacheRunnable implements Runnable {
public void run() {
enableFilters(false);
treeManager.removeAll();
treeManager.update(true);
pageBook.showPage(memcache);
}
}
protected void onNavigate(Runnable toRun) {
if (LicenseChecker.checkLicense(true)){
super.onNavigate(toRun);
}
}
protected void createHyperLinks() {
createLink("Overview", "/icons/overview_obj.gif",
new ShowOverViewRunnable());
createViewerConfigurationLink("Method list", "/icons/ListChange.gif",
fact.getMethodListConfiguration());
createViewerConfigurationLink("Call tree", "/icons/tree_mode.png", fact
.getCallGraphConfiguration());
// createViewerConfigurationLink("Inverted call tree view",
// "/icons/sort-position.gif", fact
// .getInvertedCallGraphConfiguration());
createViewerConfigurationLink("Packages", "/icons/in-package.gif", fact
.getPackageTreeConfiguration());
createLink("Top data store calls", "/icons/repository-synchronize.gif",
new ShowDataStoreRunnable());
createLink("Mem cache analysis", "/icons/cog.png",
new ShowMemCacheRunnable());
}
protected void createLowBarControls(Composite lowBar) {
GridLayout layout = new GridLayout(9, false);
layout.marginHeight = 0;
lowBar.setLayout(layout);
formToolkit.createLabel(lowBar, "Name Filter:");
patternText = formToolkit.createText(lowBar, "");
patternText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
sheduleFilterAdjust();
}
});
patternText.setTextLimit(20);
// parent.setLayout(new GridLayout(1, false));
formToolkit.createLabel(lowBar, "Filter mode:");
filterMode = new Combo(lowBar, SWT.READ_ONLY);
filterMode.setTextLimit(20);
patternText.setLayoutData(new GridData(100, -1));
filterMode.setLayoutData(new GridData(100, -1));
items = new ComboViewer(filterMode);
items.setContentProvider(new ArrayContentProvider());
filterMode.setEnabled(false);
filterMode.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
}
public void widgetSelected(SelectionEvent e) {
sheduleFilterAdjust();
}
});
filterLabel = formToolkit.createLabel(lowBar, "Limit:");
limitSpinner = new Spinner(lowBar, SWT.BORDER);
limitSpinner.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent e) {
sheduleFilterAdjust();
}
});
limitSpinner.setMaximum(1000000000);
limitSpinner.addSelectionListener(new SelectionListener() {
public void widgetDefaultSelected(SelectionEvent e) {
}
public void widgetSelected(SelectionEvent e) {
sheduleFilterAdjust();
}
});
limitSpinner.setLayoutData(new GridData(100, -1));
createLowBarHyperLinks(lowBar);
}
private void createLowBarHyperLinks(Composite lowBar) {
// ImageHyperlink createImageHyperlink2 = formToolkit
// .createImageHyperlink(lowBar, SWT.NONE);
// createImageHyperlink2.setText("Help");
// createImageHyperlink2.setImage(getImage("/icons/help.gif"));
}
protected ConfigurableViewer createViewer(Composite viewerHolder) {
return new PerformanceConfugurableViewer(viewerHolder, this);
}
protected void enableFilters(boolean enable) {
filterMode.setEnabled(enable);
patternText.setEnabled(enable);
limitSpinner.setEnabled(enable);
}
protected String getChartName(Object object) {
ITrace c = (ITrace) object;
return c.getShortName();
}
protected double getChartValue(Object calc, Object object) {
PercentCalculator<ITrace> pm = (PercentCalculator<ITrace>) calc;
ITrace c = (ITrace) object;
return pm.percent(c);
}
protected IFilter getViewerFilter() {
return new IFilter() {
public boolean accept(Object o) {
SnapshotFilter modelFilter = data.getModelFilter();
if (modelFilter != null) {
return modelFilter.accept((ITrace) o);
}
return true;
}
public Point match(String text) {
SnapshotFilter modelFilter = data.getModelFilter();
if (modelFilter != null) {
String pattern = modelFilter.pattern;
int indexOf = text.toLowerCase().indexOf(
pattern.toLowerCase());
if (indexOf != -1) {
return new Point(indexOf, modelFilter.pattern.length());
}
return null;
}
return null;
}
};
}
protected void handleOpen(Object object) {
IMethod result = null;
result = findMethod(object);
if (result != null) {
try {
IEditorPart openInEditor = EditorUtility.openInEditor(result);
EditorUtility.revealInEditor(openInEditor, result);
return;
} catch (PartInitException e) {
Activator.getDefault().log(e);
}
}
MessageDialog.openInformation(Display.getCurrent().getActiveShell(),
"Source lookup failed", "Unable to method method :"
+ ((AccumulatedMethod) object).getName()
+ " on java element in current project");
}
private WeakHashMap<Object, IMethod> mn = new WeakHashMap<Object, IMethod>();
private WeakHashMap<String, IType> tp = new WeakHashMap<String, IType>();
long t0;
private IMethod findMethod(Object object) {
long l0 = System.currentTimeMillis();
try {
IMethod iMethod = mn.get(object);
if (iMethod != null) {
return iMethod;
}
IProject prj = ((IFileEditorInput) getEditorInput()).getFile()
.getProject();
IJavaProject create = JavaCore.create(prj);
AccumulatedMethod m = (AccumulatedMethod) object;
IType findType;
try {
String replace = m.getClassName().replace('$', '.');
findType = tp.get(replace);
if (findType == null) {
findType = create.findType(replace);
tp.put(replace, findType);
}
if (findType == null) {
// TODO FIXME
// findType=create.findType(m.getClassName().replace('$',
// '.'),new NullProgressMonitor());
}
if (findType != null) {
return findMethodInType(object, m, findType, null);
}
} catch (JavaModelException e) {
Activator.getDefault().log(e);
}
} finally {
long l1 = System.currentTimeMillis();
t0 += (l1 - l0);
// System.out.println("Timing:" + (t0));
}
return null;
}
private IMethod findMethodInType(Object object, AccumulatedMethod m,
IType findType, ITypeHierarchy t) throws JavaModelException {
if (findType == null) {
return null;
}
IMethod[] methods = findType.getMethods();
String[] signature = m.getParameterTypeNames();
l2: for (IMethod mq : methods) {
if (mq.getElementName().equals(m.getMethodName())
|| (m.getMethodName().equals("<init>") && mq
.isConstructor())) {
String[] parameterTypes = mq.getParameterTypes();
int a = 0;
if (parameterTypes.length != signature.length) {
continue;
}
for (String s : parameterTypes) {
if (!matches(s, signature[a++])) {
continue l2;
}
}
mn.put(object, mq);
return mq;
}
}
if (t == null) {
t = findType.newSupertypeHierarchy(new NullProgressMonitor());
}
IType superclass = t.getSuperclass(findType);
IMethod findMethodInType = findMethodInType(m, m, superclass, t);
if (findMethodInType != null) {
mn.put(object, findMethodInType);
return findMethodInType;
}
IType[] superInterfaces = t.getSuperInterfaces(findType);
for (IType tt : superInterfaces) {
findMethodInType = findMethodInType(m, m, tt, t);
if (findMethodInType != null) {
mn.put(object, findMethodInType);
return findMethodInType;
}
}
return null;
}
private boolean matches(String s, String string) {
if (s.equals(string)) {
return true;
}
String typeErasure = Signature.getTypeErasure(s);
if (typeErasure != null) {
if (typeErasure.charAt(0) == 'T') {
return true;
}
String signatureSimpleName = Signature
.getSignatureSimpleName(typeErasure);
int lastIndexOf = string.lastIndexOf('/');
if (lastIndexOf != -1) {
string = string.substring(lastIndexOf + 1, string.length() - 1);
int lms = string.lastIndexOf('$');
if (lms != -1) {
string = string.substring(lms + 1);
}
if (string.equals(signatureSimpleName)) {
return true;
}
}
}
return false;
}
public void onSetActiveConfig(ViewerConfiguration config) {
fact.setActiveConfig(config);
ISelection selection = items.getSelection();
items.setInput(config.getModes());
items.setSelection(selection);
if (filterMode.getSelectionIndex() == -1) {
setupNewFilter();
}
}
ResourceFilterInfo resourceFilterInfo;
protected void setupNewFilter() {
String pattern = patternText.getText();
IStructuredSelection selection = (IStructuredSelection) items
.getSelection();
int mode = 0;
if (!selection.isEmpty()) {
FilterMode moded = (FilterMode) selection.getFirstElement();
mode = moded.getMode();
filterLabel.setText(moded.getLimitLabel());
limitSpinner.setEnabled(true);
filterLabel.getParent().layout(new Control[] { filterLabel });
} else {
filterLabel.setText("Limit:");
filterLabel.getParent().layout(new Control[] { filterLabel });
limitSpinner.setEnabled(false);
}
int value = limitSpinner.getSelection();
data.setModelFilter(new ResourceSnapshotFilter(mode, value, pattern,
resourceFilterInfo));
refilter = true;
try {
// createForm.setBusy(true);
form.getHead().update();
viewer.refresh();
} finally {
// createForm.setBusy(false);
refilter = false;
}
}
protected void updateTitle(Object input) {
}
public IMethod getMethod(Object trace) {
return findMethod(trace);
}
private String getReqestMessage(RequestInfo r) {
StackTraceElement stackTraceElement = r.getStackTrace()[0];
String methodName = stackTraceElement.getMethodName();
String cl = stackTraceElement.getClassName();
int lastIndexOf = cl.lastIndexOf('.');
if (lastIndexOf != -1) {
cl = cl.substring(lastIndexOf);
}
return methodName + " - " + r.getMessage();
}
private void doOpenStacktrace(StackTraceElement sm) {
if (sm != null) {
int lineNumber = sm.getLineNumber();
IProject prj = ((IFileEditorInput) getEditorInput()).getFile()
.getProject();
IJavaProject create = JavaCore.create(prj);
IType findType;
try {
String replace = sm.getClassName().replace('$', '.');
findType = tp.get(replace);
if (findType == null) {
findType = create.findType(replace);
tp.put(replace, findType);
}
if (findType != null) {
IType tp = findType;
IEditorPart editorPart = EditorUtility.openInEditor(tp);
IEditorInput editorInput = editorPart.getEditorInput();
if (editorPart instanceof ITextEditor && lineNumber >= 0) {
ITextEditor textEditor = (ITextEditor) editorPart;
IDocumentProvider provider = textEditor
.getDocumentProvider();
provider.connect(editorInput);
IDocument document = null;
document = provider.getDocument(editorInput);
try {
IRegion line = document
.getLineInformation(lineNumber - 1);
textEditor.selectAndReveal(line.getOffset(), line
.getLength());
} catch (BadLocationException e) {
}
provider.disconnect(editorInput);
}
}
} catch (JavaModelException e) {
Activator.getDefault().log(e);
} catch (CoreException e) {
Activator.getDefault().log(e);
}
}
}
}