Package org.erlide.tracing.core.utils

Source Code of org.erlide.tracing.core.utils.TraceDataHandler

package org.erlide.tracing.core.utils;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.erlide.tracing.core.Activator;
import org.erlide.tracing.core.Images;
import org.erlide.tracing.core.TraceType;
import org.erlide.tracing.core.mvc.model.treenodes.FunctionNode;
import org.erlide.tracing.core.mvc.model.treenodes.ITreeNode;
import org.erlide.tracing.core.mvc.model.treenodes.ModuleNode;
import org.erlide.tracing.core.mvc.model.treenodes.TracingResultsNode;
import org.erlide.tracing.core.mvc.model.treenodes.TreeNode;
import org.erlide.util.ErlLogger;

import com.ericsson.otp.erlang.OtpErlangAtom;
import com.ericsson.otp.erlang.OtpErlangInt;
import com.ericsson.otp.erlang.OtpErlangList;
import com.ericsson.otp.erlang.OtpErlangLong;
import com.ericsson.otp.erlang.OtpErlangObject;
import com.ericsson.otp.erlang.OtpErlangPid;
import com.ericsson.otp.erlang.OtpErlangRangeException;
import com.ericsson.otp.erlang.OtpErlangString;
import com.ericsson.otp.erlang.OtpErlangTuple;

/**
* Handler which reads trace data.
*
* @author Piotr Dorobisz
*
*/
public class TraceDataHandler {

    // atoms
    private static final String ATOM_ERROR_LOADING = "error_loading";
    private static final Object ATOM_FILE_INFO = "file_info";
    private static final Object ATOM_DROP = "drop";
    private static final String ATOM_STOP_TRACING = "stop_tracing";
    private static final String ATOM_TRACE_TS = "trace_ts";

    // trace tuple fields
    private static final int INDEX_PROCESS = 1;
    private static final int INDEX_PROCESS_PID = 0;
    private static final int INDEX_PROCESS_INFO = 1;
    private static final int INDEX_PROCESS_NODE = 2;

    private static final int INDEX_TRACE_TYPE = 2;

    private static final int INDEX_FUNCTION = 3;
    private static final int INDEX_FUNCTION_MODULE = 0;
    private static final int INDEX_FUNCTION_NAME = 1;
    private static final int INDEX_FUNCTION_ARGS = 2;

    private static final int INDEX_MESSAGE = 3;
    private static final int INDEX_REGNAME = 3;
    private static final int INDEX_REASON = 3;
    private static final int INDEX_PROCESS2 = 3;
    private static final int INDEX_INFO = 3;

    private static final int INDEX_EXCEPTION = 4;
    private static final int INDEX_EXCEPTION_CLASS = 0;
    private static final int INDEX_EXCEPTION_VALUE = 1;

    private static final int INDEX_TO = 4;
    private static final int INDEX_RETURN_VALUE = 4;
    private static final int INDEX_SPAWN_FUNCTION = 4;

    // file info tuple fields
    private static final int INDEX_INFO_START_DATE = 1;
    private static final int INDEX_INFO_END_DATE = 2;
    private static final int INDEX_INFO_PATH = 3;
    private static final int INDEX_INFO_COUNT = 4;

    private Date lastTraceDate;
    private String lastProcessDescription;
    private String lastFunctionDescription;
    private final SimpleDateFormat infoDateFormatter = new SimpleDateFormat(
            "dd.MM.yy HH:mm:ss");
    private final SimpleDateFormat nodeDateFormatter = new SimpleDateFormat(
            "HH:mm:ss.SSS dd.MM.yy");

    /**
     * Checks if given message is last one.
     *
     * @param message
     *            message
     * @return <code>true</code> if it is last message, <code>false</code>
     *         otherwise
     */
    public boolean isTracingFinished(final OtpErlangObject message) {
        if (message instanceof OtpErlangAtom) {
            final OtpErlangAtom atom = (OtpErlangAtom) message;
            if (atom.atomValue().equals(ATOM_STOP_TRACING)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Reads error reason from message.
     *
     * @param message
     *            message
     * @return error reason or <code>null</code> or if it is not an error
     *         message
     */
    public OtpErlangObject getErrorReson(final OtpErlangObject message) {
        if (message instanceof OtpErlangTuple) {
            final OtpErlangTuple tuple = (OtpErlangTuple) message;
            if (tuple.elementAt(0) instanceof OtpErlangAtom) {
                final OtpErlangAtom atom = (OtpErlangAtom) tuple.elementAt(0);
                if (atom.atomValue().equals(ATOM_ERROR_LOADING)) {
                    return tuple.elementAt(1);
                }
            }
        }
        return null;
    }

    /**
     * Reads data described by given object. It can be trace event or
     * information about file containing tracing results.
     *
     * @param otpErlangObject
     *            input object
     *
     * @return tree node that describes data
     */
    public ITreeNode getData(final OtpErlangObject otpErlangObject) {
        try {
            if (otpErlangObject instanceof OtpErlangTuple) {
                final OtpErlangTuple tuple = (OtpErlangTuple) otpErlangObject;

                final String atomValue = ((OtpErlangAtom) tuple.elementAt(0)).atomValue();
                if (atomValue.equals(ATOM_TRACE_TS)) {
                    // trace data: {trace_ts, Data}

                    final OtpErlangAtom traceType = (OtpErlangAtom) tuple
                            .elementAt(INDEX_TRACE_TYPE);
                    lastTraceDate = readDateTuple((OtpErlangTuple) tuple.elementAt(tuple
                            .arity() - 1));

                    switch (TraceType.valueOf(traceType.atomValue().toUpperCase())) {
                    case CALL:
                        return processCallTrace("Call", tuple);
                    case EXCEPTION_FROM:
                        return processExceptionFrom("Exception", tuple);
                    case EXIT:
                        return processExitTrace("Exit", tuple);
                    case GC_END:
                        return processGcTrace("GC end", Images.GC_END_NODE, tuple);
                    case GC_START:
                        return processGcTrace("GC start", Images.GC_START_NODE, tuple);
                    case GETTING_LINKED:
                        return processLinkTrace("Getting linked",
                                Images.GETTING_LINKED_NODE, tuple);
                    case GETTING_UNLINKED:
                        return processLinkTrace("Getting unlinked",
                                Images.GETTING_UNLINKED_NODE, tuple);
                    case IN:
                        return processInOutTrace("In", Images.IN_NODE, tuple);
                    case LINK:
                        return processLinkTrace("Link", Images.LINK_NODE, tuple);
                    case OUT:
                        return processInOutTrace("Out", Images.OUT_NODE, tuple);
                    case RECEIVE:
                        return processReceiveTrace("Received", tuple);
                    case REGISTER:
                        return processRegisterTrace("Register", Images.REGISTER_NODE,
                                tuple);
                    case RETURN_FROM:
                        return processReturnTrace("Return from", Images.RETURN_FROM_NODE,
                                tuple, true);
                    case RETURN_TO:
                        return processReturnTrace("Return to", Images.RETURN_TO_NODE,
                                tuple, false);
                    case SEND:
                        return processSendTrace("Sent", Images.SENT_MESSAGE_NODE, tuple);
                    case SEND_TO_NON_EXISTING_PROCESS:
                        return processSendTrace("Sent to non existing process",
                                Images.WRONG_MESSAGE_NODE, tuple);
                    case SPAWN:
                        return processSpawnTrace("Spawn", tuple);
                    case UNLINK:
                        return processLinkTrace("Unlink", Images.ULINK_NODE, tuple);
                    case UNREGISTER:
                        return processRegisterTrace("Unregister", Images.UNREGISTER_NODE,
                                tuple);
                    }
                } else if (atomValue.equals(ATOM_FILE_INFO)) {
                    return processFileInfo(tuple);
                } else if (atomValue.equals(ATOM_DROP)) {
                    // drop information: {drop, Long}
                    return processDropTrace(tuple);
                }
            }
        } catch (final Exception e) {
            ErlLogger.error(e);
        }
        return null;
    }

    /**
     * Converts tuple representing date and time (<code>{date(), time()}</code>)
     * to java {@link Date} object.
     *
     * @param tuple
     *            date tuple
     * @return java date
     * @throws OtpErlangRangeException
     */
    private Date readDateTuple(final OtpErlangTuple tuple) throws OtpErlangRangeException {
        final OtpErlangTuple dateTuple = (OtpErlangTuple) tuple.elementAt(0);
        final OtpErlangTuple timeTuple = (OtpErlangTuple) tuple.elementAt(1);

        final int year = ((OtpErlangLong) dateTuple.elementAt(0)).intValue();
        final int month = ((OtpErlangLong) dateTuple.elementAt(1)).intValue() - 1;
        final int day = ((OtpErlangLong) dateTuple.elementAt(2)).intValue();
        final int hour = ((OtpErlangLong) timeTuple.elementAt(0)).intValue();
        final int minute = ((OtpErlangLong) timeTuple.elementAt(1)).intValue();
        final int second = ((OtpErlangLong) timeTuple.elementAt(2)).intValue();

        final Calendar calendar = Calendar.getInstance();
        calendar.set(year, month, day, hour, minute, second);

        return calendar.getTime();
    }

    private String createNodeLabel(final String text) {
        return "[" + nodeDateFormatter.format(lastTraceDate) + "] " + text;
    }

    private String pid2Str(final OtpErlangPid pid) {
        return new StringBuilder().append(pid.id()).append(".").append(pid.serial())
                .append(".").append(pid.creation()).toString();
    }

    // functions creating nodes

    private ITreeNode processDropTrace(final OtpErlangTuple tuple) {
        final OtpErlangLong amount = (OtpErlangLong) tuple.elementAt(1);
        final ITreeNode node = new TreeNode("Dropped traces: " + amount.longValue(),
                Activator.getImage(Images.DROP_NODE));
        return node;
    }

    private ITreeNode processFileInfo(final OtpErlangTuple tuple) {
        TracingResultsNode node = null;
        if (tuple.elementAt(INDEX_INFO_START_DATE) instanceof OtpErlangAtom) {
            // file contains no trace events
            return null;
        }
        try {
            final Date from = readDateTuple((OtpErlangTuple) tuple
                    .elementAt(INDEX_INFO_START_DATE));
            final Date to = readDateTuple((OtpErlangTuple) tuple
                    .elementAt(INDEX_INFO_END_DATE));
            final String path = ((OtpErlangString) tuple.elementAt(INDEX_INFO_PATH))
                    .stringValue();
            final long size = ((OtpErlangLong) tuple.elementAt(INDEX_INFO_COUNT))
                    .longValue();

            node = new TracingResultsNode();
            node.setStartDate(from);
            node.setEndDate(to);
            node.setFileName(path);
            node.setSize(size);

            // node label
            final StringBuilder builder = new StringBuilder();
            builder.append(infoDateFormatter.format(from)).append(" - ")
                    .append(infoDateFormatter.format(to)).append(" (").append(size)
                    .append(" traces): ").append(path);
            node.setLabel(builder.toString());

        } catch (final OtpErlangRangeException e) {
            ErlLogger.error(e);
        }
        return node;
    }

    private ITreeNode createProcessNode(final String label,
            final OtpErlangObject erlangObject) {
        final StringBuilder builder = new StringBuilder();
        ITreeNode functionNode = null;
        ITreeNode nameNode = null;
        ITreeNode pidNode = null;
        ITreeNode processNodeNode = null;

        if (erlangObject instanceof OtpErlangTuple) {
            // tuple: {Pid(), Initial_call()|Registered_name(), Node()} |
            // {Registered_name, Node()}
            final OtpErlangTuple processTuple = (OtpErlangTuple) erlangObject;
            int index = 0;

            // pid
            OtpErlangPid pid = null;
            if (processTuple.arity() == 3) {
                // {Pid(), Initial_call()|Registered_name(), Node()}
                pid = (OtpErlangPid) processTuple.elementAt(INDEX_PROCESS_PID);
                pidNode = new TreeNode("pid: " + pid2Str(pid),
                        Activator.getImage(Images.INFO_NODE));
            } else {
                index = 1;// tuple doesn't contain Pid element
            }

            final OtpErlangObject info = processTuple.elementAt(INDEX_PROCESS_INFO
                    - index);

            // process node
            final OtpErlangObject processNode = processTuple.elementAt(INDEX_PROCESS_NODE
                    - index);
            processNodeNode = new TreeNode("node: " + processNode,
                    Activator.getImage(Images.INFO_NODE));

            if (info instanceof OtpErlangTuple) {
                // initial call
                functionNode = createFunctionNode("initial call:", info);
                functionNode.setImage(Activator.getImage(Images.INFO_NODE));
                if (pid != null) {
                    builder.append(pid2Str(pid));
                } else {
                    builder.append(lastFunctionDescription);
                }
            } else {
                // registered name
                nameNode = new TreeNode("name: " + info,
                        Activator.getImage(Images.INFO_NODE));
                builder.append(info.toString());
            }
            builder.append(" (").append(processNode).append(")");
        } else if (erlangObject instanceof OtpErlangPid) {
            // Pid
            final OtpErlangPid pid = (OtpErlangPid) erlangObject;
            pidNode = new TreeNode("pid: " + pid2Str(pid),
                    Activator.getImage(Images.INFO_NODE));
            processNodeNode = new TreeNode("node: " + pid.node(),
                    Activator.getImage(Images.INFO_NODE));
            builder.append(pid2Str(pid)).append(" (").append(pid.node()).append(")");
        } else {
            // Atom (registered name)
            nameNode = new TreeNode("name: " + erlangObject,
                    Activator.getImage(Images.INFO_NODE));
            builder.append(erlangObject.toString());
        }

        final ITreeNode node = new TreeNode();
        if (pidNode != null) {
            node.addChildren(pidNode);
        }
        if (nameNode != null) {
            node.addChildren(nameNode);
        }
        if (processNodeNode != null) {
            node.addChildren(processNodeNode);
        }
        if (functionNode != null) {
            node.addChildren(functionNode);
        }

        lastProcessDescription = builder.toString();
        node.setLabel(label + lastProcessDescription);

        return node;
    }

    private ITreeNode createFunctionNode(final String label,
            final OtpErlangObject erlangObject) {
        final ITreeNode node = new TreeNode();
        if (erlangObject instanceof OtpErlangTuple) {
            final OtpErlangTuple functionTuple = (OtpErlangTuple) erlangObject;
            final OtpErlangAtom moduleName = (OtpErlangAtom) functionTuple
                    .elementAt(INDEX_FUNCTION_MODULE);
            final OtpErlangAtom functionName = (OtpErlangAtom) functionTuple
                    .elementAt(INDEX_FUNCTION_NAME);

            // args or arity node
            final TreeNode argsNode = new TreeNode();
            argsNode.setImage(Activator.getImage(Images.INFO_NODE));
            final OtpErlangObject arityOrArgs = functionTuple
                    .elementAt(INDEX_FUNCTION_ARGS);
            int arityValue = -1;
            if (arityOrArgs instanceof OtpErlangList) {
                // last element is a list of arguments
                final OtpErlangList arguments = (OtpErlangList) arityOrArgs;
                final StringBuilder builder = new StringBuilder("arguments: ");
                for (int i = 1; i < arguments.arity(); i++) {
                    builder.append(arguments.elementAt(i)).append(", ");
                }
                arityValue = arguments.arity() - 1;
                argsNode.setLabel(builder.substring(0, builder.length() - 2));
            } else {
                // last element is arity
                try {
                    if (functionTuple.elementAt(INDEX_FUNCTION_ARGS) instanceof OtpErlangInt) {
                        arityValue = ((OtpErlangInt) functionTuple
                                .elementAt(INDEX_FUNCTION_ARGS)).intValue();
                    } else {
                        arityValue = (int) ((OtpErlangLong) functionTuple
                                .elementAt(INDEX_FUNCTION_ARGS)).longValue();
                    }
                    argsNode.setLabel("arity: " + arityValue);
                } catch (final OtpErlangRangeException e) {
                    ErlLogger.error(e);
                }
            }

            // module name node
            final TreeNode moduleNameNode = new ModuleNode(moduleName.atomValue());
            moduleNameNode.setLabel("module: " + moduleName);

            // function name node
            final TreeNode functionNameNode = new FunctionNode(moduleName.atomValue(),
                    functionName.atomValue(), arityValue);
            functionNameNode.setLabel("function: " + functionName);

            node.addChildren(moduleNameNode, functionNameNode, argsNode);
            lastFunctionDescription = label + moduleName + ":" + functionName + "/"
                    + arityValue;

        } else {
            lastFunctionDescription = "unknown";
        }
        node.setLabel(lastFunctionDescription);
        return node;
    }

    private ITreeNode createMessageNode(final OtpErlangObject message) {
        final ITreeNode node = new TreeNode(message.toString(),
                Activator.getImage(Images.MESSAGE_NODE));
        return node;
    }

    // functions processing different trace types

    private ITreeNode processGcTrace(final String label, final Images image,
            final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));
        labelBuilder.append(lastProcessDescription);

        final ITreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()),
                Activator.getImage(image));
        node.addChildren(processNode);

        final OtpErlangList list = (OtpErlangList) tuple.elementAt(INDEX_INFO);
        for (final OtpErlangObject otpErlangObject : list) {
            final OtpErlangTuple infoTuple = (OtpErlangTuple) otpErlangObject;
            final OtpErlangObject key = infoTuple.elementAt(0);
            final OtpErlangObject value = infoTuple.elementAt(1);
            final TreeNode treeNode = new TreeNode(key.toString() + ": "
                    + value.toString());
            treeNode.setImage(Activator.getImage(Images.INFO_NODE));
            node.addChildren(treeNode);
        }
        return node;
    }

    private ITreeNode processSpawnTrace(final String label, final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));
        labelBuilder.append(lastProcessDescription).append("->");

        final ITreeNode processNode2 = createProcessNode("new process: ",
                tuple.elementAt(INDEX_PROCESS2));
        processNode2.setImage(Activator.getImage(Images.NEW_PROCESS_NODE));
        labelBuilder.append(lastProcessDescription);

        final ITreeNode functionNode = createFunctionNode("function: ",
                tuple.elementAt(INDEX_SPAWN_FUNCTION));
        functionNode.setImage(Activator.getImage(Images.FUNCTION_NODE));

        final ITreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()),
                Activator.getImage(Images.SPAWN_NODE));
        node.addChildren(processNode, processNode2, functionNode);
        return node;
    }

    private ITreeNode processExceptionFrom(final String label, final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));

        final OtpErlangTuple exceptionTuple = (OtpErlangTuple) tuple
                .elementAt(INDEX_EXCEPTION);
        final OtpErlangObject exceptionClass = exceptionTuple
                .elementAt(INDEX_EXCEPTION_CLASS);
        final OtpErlangObject exceptionValue = exceptionTuple
                .elementAt(INDEX_EXCEPTION_VALUE);
        labelBuilder.append(exceptionClass.toString());

        final ITreeNode exceptionClassNode = new TreeNode(exceptionClass.toString(),
                Activator.getImage(Images.INFO_NODE));
        exceptionClassNode.addChildren(new TreeNode(exceptionValue.toString()));

        final ITreeNode node = processReturnTrace(labelBuilder.toString(),
                Images.EXCEPTION_NODE, tuple, false);
        node.addChildren(processNode, exceptionClassNode);
        return node;
    }

    private ITreeNode processReturnTrace(final String label, final Images image,
            final OtpErlangTuple tuple, final boolean showRetValue) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));

        final ITreeNode functionNode = createFunctionNode("function: ",
                tuple.elementAt(INDEX_FUNCTION));
        functionNode.setImage(Activator.getImage(Images.FUNCTION_NODE));
        labelBuilder.append(lastFunctionDescription);

        final ITreeNode node = new TreeNode();
        node.addChildren(processNode, functionNode);

        if (showRetValue) {
            final ITreeNode returnValueNode = new TreeNode("return value: "
                    + tuple.elementAt(INDEX_RETURN_VALUE));
            returnValueNode.setImage(Activator.getImage(Images.INFO_NODE));
            labelBuilder.append("->").append(tuple.elementAt(INDEX_RETURN_VALUE));
            node.addChildren(returnValueNode);
        }

        node.setLabel(createNodeLabel(labelBuilder.toString()));
        node.setImage(Activator.getImage(image));
        return node;
    }

    private ITreeNode processInOutTrace(final String label, final Images image,
            final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));
        labelBuilder.append(lastProcessDescription);

        final ITreeNode functionNode = createFunctionNode("function: ",
                tuple.elementAt(INDEX_FUNCTION));
        functionNode.setImage(Activator.getImage(Images.FUNCTION_NODE));

        final ITreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()),
                Activator.getImage(image));
        node.addChildren(processNode, functionNode);
        return node;
    }

    private ITreeNode processRegisterTrace(final String label, final Images image,
            final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode process = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        process.setImage(Activator.getImage(Images.REGISTER_NODE));
        labelBuilder.append(lastProcessDescription).append("->");

        final TreeNode regName = new TreeNode("name: "
                + tuple.elementAt(INDEX_REGNAME).toString(),
                Activator.getImage(Images.INFO_NODE));
        labelBuilder.append(regName);

        final ITreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()),
                Activator.getImage(image));
        node.addChildren(process, regName);
        return node;
    }

    private ITreeNode processLinkTrace(final String label, final Images image,
            final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode process1Node = createProcessNode("process 1: ",
                tuple.elementAt(INDEX_PROCESS));
        process1Node.setImage(Activator.getImage(Images.PROCESS_NODE));
        labelBuilder.append(lastProcessDescription).append("->");

        final ITreeNode process2Node = createProcessNode("process 2: ",
                tuple.elementAt(INDEX_PROCESS2));
        process2Node.setImage(Activator.getImage(Images.PROCESS_NODE));
        labelBuilder.append(lastProcessDescription);

        final TreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()));
        node.setImage(Activator.getImage(image));
        node.addChildren(process1Node, process2Node);
        return node;
    }

    private ITreeNode processExitTrace(final String label, final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));
        labelBuilder.append(lastProcessDescription);

        final ITreeNode reasonNode = new TreeNode("reason: "
                + tuple.elementAt(INDEX_REASON).toString(),
                Activator.getImage(Images.INFO_NODE));

        final TreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()));
        node.setImage(Activator.getDefault().getImageRegistry()
                .get(Images.EXIT_NODE.toString()));
        node.addChildren(processNode, reasonNode);
        return node;
    }

    private ITreeNode processReceiveTrace(final String label, final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode processNode = createProcessNode("receiver: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.RECEIVER_NODE));
        labelBuilder.append(lastProcessDescription);

        final ITreeNode messageNode = createMessageNode(tuple.elementAt(INDEX_MESSAGE));

        final TreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()));
        node.setImage(Activator.getDefault().getImageRegistry()
                .get(Images.RECEIVED_MESSAGE_NODE.toString()));
        node.addChildren(processNode, messageNode);
        return node;
    }

    private ITreeNode processSendTrace(final String label, final Images image,
            final OtpErlangTuple tuple) {
        final StringBuilder labelBuilder = new StringBuilder(label).append(": ");

        final ITreeNode senderNode = createProcessNode("sender: ",
                tuple.elementAt(INDEX_PROCESS));
        senderNode.setImage(Activator.getImage(Images.SENDER_NODE));
        labelBuilder.append(lastProcessDescription).append("->");

        final ITreeNode receiverNode = createProcessNode("receiver: ",
                tuple.elementAt(INDEX_TO));
        receiverNode.setImage(Activator.getImage(Images.RECEIVER_NODE));
        labelBuilder.append(lastProcessDescription);

        final ITreeNode messageNode = createMessageNode(tuple.elementAt(INDEX_MESSAGE));

        final TreeNode node = new TreeNode(createNodeLabel(labelBuilder.toString()));
        node.setImage(Activator.getImage(image));
        node.addChildren(senderNode, receiverNode, messageNode);
        return node;
    }

    private ITreeNode processCallTrace(final String label, final OtpErlangTuple tuple) {
        final ITreeNode processNode = createProcessNode("process: ",
                tuple.elementAt(INDEX_PROCESS));
        processNode.setImage(Activator.getImage(Images.PROCESS_NODE));

        final ITreeNode node = createFunctionNode(createNodeLabel(label + ": "),
                tuple.elementAt(INDEX_FUNCTION));
        node.setImage(Activator.getImage(Images.CALL_NODE));
        node.addChildren(processNode);
        return node;
    }
}
TOP

Related Classes of org.erlide.tracing.core.utils.TraceDataHandler

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.