Examples with TmfFilterContainsNode org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterContainsNode used on opensource projects

Example 6 with TmfFilterContainsNode

use of org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterContainsNode in project tracecompass by tracecompass.

the class FilterViewer method fillContextMenuForNode.

/**
 * Fill the context menu with the valid children of the provided node
 *
 * @param node
 *            The target node
 * @param manager
 *            The menu manager
 */
protected void fillContextMenuForNode(final ITmfFilterTreeNode node, IMenuManager manager) {
    for (final String child : node.getValidChildren()) {
        final Action action = new Action() {

            @Override
            public void run() {
                ITmfFilterTreeNode newNode = null;
                if (TmfFilterNode.NODE_NAME.equals(child)) {
                    // $NON-NLS-1$
                    newNode = new TmfFilterNode(node, "");
                } else if (TmfFilterTraceTypeNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterTraceTypeNode(node);
                } else if (TmfFilterAndNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterAndNode(node);
                } else if (TmfFilterOrNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterOrNode(node);
                } else if (TmfFilterContainsNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterContainsNode(node);
                } else if (TmfFilterEqualsNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterEqualsNode(node);
                } else if (TmfFilterMatchesNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterMatchesNode(node);
                } else if (TmfFilterCompareNode.NODE_NAME.equals(child)) {
                    newNode = new TmfFilterCompareNode(node);
                }
                if (newNode != null) {
                    fViewer.refresh();
                    fViewer.setSelection(new StructuredSelection(newNode), true);
                }
            }
        };
        if (TmfFilterNode.NODE_NAME.equals(child)) {
            // $NON-NLS-1$
            action.setText(Messages.FilterViewer_NewPrefix + " " + child);
        } else {
            action.setText(child);
        }
        manager.add(action);
    }
}

Example 7 with TmfFilterContainsNode

use of org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterContainsNode in project tracecompass by tracecompass.

the class TmfFilterXMLWriter method buildXMLTree.

/**
 * The Tree to XML parser
 *
 * @param document The XML document
 * @param treenode The node to write
 * @param parentElement The XML element of the parent
 */
public static void buildXMLTree(final Document document, final ITmfFilterTreeNode treenode, Element parentElement) {
    Element element = document.createElement(treenode.getNodeName());
    if (treenode instanceof ITmfFilterWithNot && ((ITmfFilterWithNot) treenode).isNot()) {
        element.setAttribute(ITmfFilterWithNot.NOT_ATTRIBUTE, Boolean.TRUE.toString());
    }
    if (treenode instanceof ITmfFilterWithValue) {
        ITmfFilterWithValue node = (ITmfFilterWithValue) treenode;
        element.setAttribute(ITmfFilterWithValue.VALUE_ATTRIBUTE, node.getValue());
    }
    if (treenode instanceof TmfFilterNode) {
        TmfFilterNode node = (TmfFilterNode) treenode;
        element.setAttribute(TmfFilterNode.NAME_ATTR, node.getFilterName());
    } else if (treenode instanceof TmfFilterTraceTypeNode) {
        TmfFilterTraceTypeNode node = (TmfFilterTraceTypeNode) treenode;
        element.setAttribute(TmfFilterTraceTypeNode.TYPE_ATTR, node.getTraceTypeId());
        element.setAttribute(TmfFilterTraceTypeNode.NAME_ATTR, node.getName());
    } else if (treenode instanceof TmfFilterContainsNode) {
        TmfFilterContainsNode node = (TmfFilterContainsNode) treenode;
        setAspectAttributes(element, node);
        element.setAttribute(TmfFilterContainsNode.IGNORECASE_ATTR, Boolean.toString(node.isIgnoreCase()));
    } else if (treenode instanceof TmfFilterEqualsNode) {
        TmfFilterEqualsNode node = (TmfFilterEqualsNode) treenode;
        setAspectAttributes(element, node);
        element.setAttribute(TmfFilterEqualsNode.IGNORECASE_ATTR, Boolean.toString(node.isIgnoreCase()));
    } else if (treenode instanceof TmfFilterMatchesNode) {
        TmfFilterMatchesNode node = (TmfFilterMatchesNode) treenode;
        setAspectAttributes(element, node);
        element.setAttribute(TmfFilterMatchesNode.REGEX_ATTR, node.getRegex());
    } else if (treenode instanceof TmfFilterCompareNode) {
        TmfFilterCompareNode node = (TmfFilterCompareNode) treenode;
        setAspectAttributes(element, node);
        element.setAttribute(TmfFilterCompareNode.RESULT_ATTR, Integer.toString(node.getResult()));
        element.setAttribute(TmfFilterCompareNode.TYPE_ATTR, node.getType().toString());
    }
    parentElement.appendChild(element);
    for (int i = 0; i < treenode.getChildrenCount(); i++) {
        buildXMLTree(document, treenode.getChild(i), element);
    }
}

Example 8 with TmfFilterContainsNode

use of org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterContainsNode in project tracecompass by tracecompass.

the class StreamListView method createPartControl.

@Override
public void createPartControl(@Nullable Composite parent) {
    // Initialize
    final Map<TmfPcapProtocol, Table> tables = new HashMap<>();
    fTableMap = tables;
    fCurrentTrace = TmfTraceManager.getInstance().getActiveTrace();
    fCurrentStream = null;
    // Add a tab folder
    fTabFolder = new CTabFolder(parent, SWT.NONE);
    fTabFolder.addSelectionListener(new SelectionAdapter() {

        @Override
        public void widgetSelected(@Nullable SelectionEvent e) {
            if (e == null) {
                return;
            }
            TmfPcapProtocol protocol = (TmfPcapProtocol) e.item.getData(KEY_PROTOCOL);
            final Table table = tables.get(protocol);
            if (table != null) {
                table.deselectAll();
            }
            fCurrentStream = null;
        }
    });
    // Add items and tables for each protocol
    for (TmfPcapProtocol protocol : TmfPcapProtocol.values()) {
        if (protocol.supportsStream()) {
            CTabItem item = new CTabItem(fTabFolder, SWT.NONE);
            item.setText(protocol.getName());
            item.setData(KEY_PROTOCOL, protocol);
            Table table = new Table(fTabFolder, SWT.NONE);
            table.setHeaderVisible(true);
            table.setLinesVisible(true);
            // Add columns to table
            for (int i = 0; i < COLUMN_NAMES.length || i < COLUMN_SIZES.length; i++) {
                TableColumn column = new TableColumn(table, SWT.NONE);
                column.setText(COLUMN_NAMES[i]);
                column.setWidth(COLUMN_SIZES[i]);
            }
            item.setControl(table);
            table.addSelectionListener(new SelectionAdapter() {

                @Override
                public void widgetSelected(@Nullable SelectionEvent e) {
                    if (e == null) {
                        return;
                    }
                    fCurrentStream = (TmfPacketStream) e.item.getData(KEY_STREAM);
                }
            });
            tables.put(protocol, table);
            // Add right click menu
            Menu menu = new Menu(table);
            MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
            menuItem.setText(Messages.StreamListView_FollowStream);
            menuItem.addListener(SWT.Selection, (@Nullable Event event) -> {
                TmfSignal signal = new TmfPacketStreamSelectedSignal(this, 0, fCurrentStream);
                TmfSignalManager.dispatchSignal(signal);
            });
            menuItem = new MenuItem(menu, SWT.PUSH);
            menuItem.setText(Messages.StreamListView_Clear);
            menuItem.addListener(SWT.Selection, (@Nullable Event event) -> {
                TmfSignal signal = new TmfPacketStreamSelectedSignal(this, 0, null);
                TmfSignalManager.dispatchSignal(signal);
            });
            menuItem = new MenuItem(menu, SWT.PUSH);
            menuItem.setText(Messages.StreamListView_ExtractAsFilter);
            menuItem.addListener(SWT.Selection, new Listener() {

                @Override
                public void handleEvent(@Nullable Event event) {
                    // Generate filter.
                    ITmfFilterTreeNode filter = generateFilter();
                    // Update view and XML
                    updateFilters(filter);
                }

                private void updateFilters(@Nullable ITmfFilterTreeNode filter) {
                    if (filter == null) {
                        return;
                    }
                    // Update XML
                    List<ITmfFilterTreeNode> filters = Lists.newArrayList(FilterManager.getSavedFilters());
                    boolean newFilter = true;
                    for (ITmfFilterTreeNode savedFilter : filters) {
                        // Use toString(explicit) equality because equals() is not implemented
                        if (savedFilter.toString(true).equals(filter.toString(true))) {
                            newFilter = false;
                            break;
                        }
                    }
                    if (newFilter) {
                        filters.add(filter);
                        FilterManager.setSavedFilters(filters.toArray(new ITmfFilterTreeNode[filters.size()]));
                    }
                    // Update Filter View
                    try {
                        final IWorkbench wb = PlatformUI.getWorkbench();
                        final IWorkbenchPage activePage = wb.getActiveWorkbenchWindow().getActivePage();
                        IViewPart view = activePage.showView(FilterView.ID);
                        FilterView filterView = (FilterView) view;
                        filterView.addFilter(filter);
                    } catch (final PartInitException e) {
                        // $NON-NLS-1$
                        TraceUtils.displayErrorMsg(Messages.StreamListView_ExtractAsFilter, "Error opening view " + FilterView.ID + e.getMessage());
                        // $NON-NLS-1$
                        Activator.logError("Error opening view " + FilterView.ID, e);
                        return;
                    }
                }

                @Nullable
                private ITmfFilterTreeNode generateFilter() {
                    TmfPacketStream stream = fCurrentStream;
                    if (stream == null) {
                        return null;
                    }
                    // First stage - root
                    String name = Messages.StreamListView_FilterName_Stream + ' ' + stream.getProtocol().getShortName() + ' ' + stream.getFirstEndpoint() + " <--> " + // $NON-NLS-1$
                    stream.getSecondEndpoint();
                    TmfFilterNode root = new TmfFilterNode(name);
                    // Second stage - and
                    TmfFilterAndNode and = new TmfFilterAndNode(root);
                    // Third stage - protocol + or
                    TmfFilterContainsNode protocolFilter = new TmfFilterContainsNode(and);
                    protocolFilter.setEventAspect(TmfBaseAspects.getContentsAspect().forField(stream.getProtocol().getName()));
                    protocolFilter.setTraceTypeId(TmfFilterAspectNode.BASE_ASPECT_ID);
                    protocolFilter.setValue(EMPTY_STRING);
                    TmfFilterOrNode or = new TmfFilterOrNode(and);
                    // Fourth stage - and
                    TmfFilterAndNode andA = new TmfFilterAndNode(or);
                    TmfFilterAndNode andB = new TmfFilterAndNode(or);
                    // Fourth stage - endpoints
                    TmfFilterContainsNode endpointAAndA = new TmfFilterContainsNode(andA);
                    endpointAAndA.setEventAspect(PcapSourceAspect.INSTANCE);
                    endpointAAndA.setTraceTypeId(PcapTrace.TRACE_TYPE_ID);
                    endpointAAndA.setValue(stream.getFirstEndpoint());
                    TmfFilterContainsNode endpointBAndA = new TmfFilterContainsNode(andA);
                    endpointBAndA.setEventAspect(PcapDestinationAspect.INSTANCE);
                    endpointBAndA.setTraceTypeId(PcapTrace.TRACE_TYPE_ID);
                    endpointBAndA.setValue(stream.getSecondEndpoint());
                    TmfFilterContainsNode endpointAAndB = new TmfFilterContainsNode(andB);
                    endpointAAndB.setEventAspect(PcapSourceAspect.INSTANCE);
                    endpointAAndB.setTraceTypeId(PcapTrace.TRACE_TYPE_ID);
                    endpointAAndB.setValue(stream.getSecondEndpoint());
                    TmfFilterContainsNode endpointBAndB = new TmfFilterContainsNode(andB);
                    endpointBAndB.setEventAspect(PcapDestinationAspect.INSTANCE);
                    endpointBAndB.setTraceTypeId(PcapTrace.TRACE_TYPE_ID);
                    endpointBAndB.setValue(stream.getFirstEndpoint());
                    return root;
                }
            });
            table.setMenu(menu);
        }
    }
    // Ask the analysis for data.
    queryAnalysis();
}

Example 9 with TmfFilterContainsNode

use of org.eclipse.tracecompass.tmf.core.filter.model.TmfFilterContainsNode in project tracecompass by tracecompass.

the class FilterSimpleExpressionCu method createConditionNode.

private TmfFilterAspectNode createConditionNode() {
    switch(fOperator) {
        case IFilterStrings.EQUAL:
            TmfFilterEqualsNode equalsNode = new TmfFilterEqualsNode(null);
            equalsNode.setValue(fValue);
            equalsNode.setNot(getNot());
            return equalsNode;
        case IFilterStrings.NOT_EQUAL:
            TmfFilterEqualsNode notEqualsNode = new TmfFilterEqualsNode(null);
            notEqualsNode.setValue(fValue);
            notEqualsNode.setNot(!getNot());
            return notEqualsNode;
        case IFilterStrings.MATCHES:
            TmfFilterMatchesNode matchesNode = new TmfFilterMatchesNode(null);
            matchesNode.setRegex(fValue);
            matchesNode.setNot(getNot());
            return matchesNode;
        case IFilterStrings.CONTAINS:
            TmfFilterContainsNode containsNode = new TmfFilterContainsNode(null);
            containsNode.setValue(fValue);
            containsNode.setNot(getNot());
            return containsNode;
        case IFilterStrings.PRESENT:
            TmfFilterMatchesNode presentNode = new TmfFilterMatchesNode(null);
            // $NON-NLS-1$
            presentNode.setRegex(".*");
            presentNode.setNot(getNot());
            return presentNode;
        case IFilterStrings.GT:
            TmfFilterCompareNode gtNode = new TmfFilterCompareNode(null);
            gtNode.setResult(1);
            gtNode.setValue(fValue);
            gtNode.setNot(getNot());
            return gtNode;
        case IFilterStrings.LT:
            TmfFilterCompareNode ltNode = new TmfFilterCompareNode(null);
            ltNode.setResult(-1);
            ltNode.setValue(fValue);
            ltNode.setNot(getNot());
            return ltNode;
        default:
            // $NON-NLS-1$
            throw new IllegalArgumentException("FilterSimpleExpression: invalid comparison operator.");
    }
}