Attachment #90067 for bug #209343

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





import org.eclipse.hyades.loaders.util.HierarchyContext;
import org.eclipse.hyades.loaders.util.XMLFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;


/**
 * @author slavescu
 */
public class IgnoredXMLFragmentLoader implements XMLFragmentLoader, BinaryFragmentLoader {
    //~ Instance fields ----------------------------------------------------------------------------

    protected HierarchyContext context;

    	// do nothing
    }

    /**
     * Inefficient, pilot version.
     * TODO These methods should invoke real setters w/o toString conversion. 
     */
	public void addAttribute(String name, byte value) {
		addAttribute(name, new Byte(value).toString());
	}

	public void addAttribute(String name, short value) {
		addAttribute(name, new Short(value).toString());
	}

	public void addAttribute(String name, int value) {
		addAttribute(name, new Integer(value).toString());
	}

	public void addAttribute(String name, long value) {
		addAttribute(name, new Long(value).toString());
	}

	public void addAttribute(String name, double value) {
		addAttribute(name, new Double(value).toString());
	}

	public void addCharacters(char[] data, int offset, int length) {
    	// do nothing
    }


    public void startChild(String name) {
    	// do nothing
    }

}

Lines 8-13 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Export-Package: org.eclipse.hyades.loaders.hierarchy,	9	Export-Package: org.eclipse.hyades.loaders.hierarchy,
10	org.eclipse.hyades.loaders.util,	10	org.eclipse.hyades.loaders.util,
		11	org.eclipse.hyades.loaders.util.binary,
11	org.eclipse.hyades.models.hierarchy,	12	org.eclipse.hyades.models.hierarchy,
12	org.eclipse.hyades.models.hierarchy.extensions,	13	org.eclipse.hyades.models.hierarchy.extensions,
13	org.eclipse.hyades.models.hierarchy.extensions.impl,	14	org.eclipse.hyades.models.hierarchy.extensions.impl,




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMonContendedEnterParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short) 1034);
	
	public static final String NAME = "monContendedEnter"; 

	public BFMonContendedEnterParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_OWNER, (int) reader.readLong(data, offset));
		
		long stackDepth = reader.readUnsignedInt(data, offset);
		
		String[] stackMethods = reader.readStringArray(data, (int)stackDepth, offset); // Possible truncation
		addAnnotation(loader, stackMethods, CALL_STACK_METHODS);

		Long[] stackLines = reader.readLongArray(data, (int)stackDepth, offset);
		addAnnotation(loader, stackLines, CALL_STACK_LINES);
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFValueParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1020);

	public static final String NAME = "value";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFAgentCreateParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1003);

	public static final String NAME = "agentCreate";

	public BFAgentCreateParser() {
		super(ID, NAME);
	}

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();
		
		loader.addAttribute(AGENT_ID, reader.readString(data, offset));
		loader.addAttribute(PROCESS_ID_REF, reader.readString(data, offset));
		loader.addAttribute(AGENT_NAME, reader.readString(data, offset));
		loader.addAttribute(AGENT_TYPE, reader.readString(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(AGENT_PARAMETERS, reader.readString(data, offset));
		loader.addAttribute(VERSION, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary;

import org.eclipse.hyades.loaders.hierarchy.IgnoredXMLFragmentLoader;

public class IgnoredBinaryFragmentLoader extends IgnoredXMLFragmentLoader implements BinaryFragmentLoader {

	public void addAttribute(String name, byte value) {
	}

	public void addAttribute(String name, short value) {
	}

	public void addAttribute(String name, int value) {
	}

	public void addAttribute(String name, long value) {
	}

	public void addAttribute(String name, double value) {
	}

}




package org.eclipse.hyades.loaders.util.binary;

import org.eclipse.hyades.loaders.util.HierarchyContext;
import org.eclipse.hyades.loaders.util.LoaderExtensions;

public abstract class BinaryFragmentParser {

	public static final String AGENT_ID = "agentId";
	
	public static final String AGENT_ID_REF = "agentIdRef";

	public static final String AGENT_NAME = "agentName";
	
	public static final String AGENT_TYPE = "agentType";
	
	public static final String PROCESS_ID_REF = "processIdRef";
	
	public static final String AGENT_PARAMETERS = "agentParameters";
	
	public static final String VERSION = "version";
	
	public static final String THREAD_ID = "threadId";

	public static final String THREAD_ID_REF = "threadIdRef";
	
	public static final String TRANS_THREAD_ID_REF = "transientThreadIdRef";
	
	public static final String TRANS_THREAD_ID= "transientThreadId";
	
	public static final String GROUP_NAME = "groupName";

	public static final String PARENT_NAME = "parentName";

	public static final String THREAD_NAME = "threadName";

	public static final String METHOD_ID = "methodId";

	public static final String METHOD_ID_REF = "methodIdRef";
	
	public static final String TIME = "time";
	
	public static final String BASE_TIME = "baseTime";
	
	public static final String MIN_TIME = "minTime";
	
	public static final String MAX_TIME = "maxTime";
	
	public static final String CPU_TIME = "cpuTime";
	
	public static final String TIMEOUT = "timeout";

	public static final String THREAD_CPU_TIME = "threadCpuTime";

	public static final String COUNT = "count";
	
	public static final String NUM_INTERFACES = "numInterfaces";
	
	public static final String INTERFACE_NAMES = "interfaceNames";
	
	public static final String CLASS_ID = "classId";
	
	public static final String CLASS_ID_REF = "classIdRef";

	public static final String TRANS_CLASS_ID = "transientClassId";
	
	public static final String TRANS_CLASS_ID_REF = "transientClassIdRef";

	public static final String CLASS_LOADER = "classLoader";
	
	public static final String SUPER_CLASS = "superClass";
	
	public static final String SOURCE_NAME = "sourceName";
	
	public static final String OBJ_ID_REF = "objIdRef";
	
	public static final String OBJ_ID = "objId";

	public static final String TRANS_OBJ_ID_REF = "transientObjIdRef";
	
	public static final String OWNER_OBJ_ID_REF = "ownerObjIdRef";
	
	public static final String TARGET_OBJ_ID_REF = "targetObjIdRef";

	public static final String OBJ_AGE = "objAge";

	public static final String NAME_ATTR = "name";
	
	public static final String ACCESS = "access";
	
	public static final String NUM_STATIC_FIELDS= "numStaticFields";
	
	public static final String NUM_METHODS = "numMethods";
	
	public static final String NUM_INSTANCE_FIELDS = "numInstanceFields";
	
	public static final String COLLATION_VALUE = "collationValue";
		
	public static final String TRACE_ID = "traceId";

	public static final String TRACE_ID_REF = "traceIdRef";
	
	public static final String PATTERN = "pattern";
	
	public static final String GENERIC_PATTERN = "genericPattern";
	
	public static final String MODE = "mode";
	
	public static final String METHOD_PATTERN = "methodPattern";
	
	public static final String METHOD_GENERIC_PATTERN = "methodGenericPattern";
	
	public static final String METHOD_MODE = "methodMode";
	
	public static final String TOTAL_OBJECT_SPACE = "totalObjectSpace";

	public static final String USED_OBJECT_SPACE = "usedObjectSpace";
	
	public static final String USED_OBJECTS = "usedObjects";

	public static final String TYPE = "type";

	public static final String HEAP_DUMP_ID_REF = "heapDumpIdRef";

	public static final String SIGNATURE = "signature";
	
	public static final String VISIBILITY = "visibility";

	public static final String IS_NATIVE = "isNative";

	public static final String IS_ABSTRACT = "isAbstract";

	public static final String IS_STATIC = "isStatic";
	
	public static final String IS_SYNCHRONIZED = "isSynchronized";

    public static final String IS_ARRAY = "isArray";

    public static final String EXCEPTIONS = "exceptions";

	public static final String START_LINE_NUMBER = "startLineNumber";

	public static final String END_LINE_NUMBER = "endLineNumber";

	public static final String SIGNATURE_NOTATION = "signatureNotation";
	
	public static final String TICKET = "ticket";

	public static final String SEQUENCE_COUNTER = "sequenceCounter";

	public static final String STACK_DEPTH = "stackDepth";
	
    public static final String ANNOTATION = "annotation";
    
    public static final String KEY = "key";

    public static final String VALUE = "value";
    
    public static final String CALL_STACK_METHODS = "callStackDumpMethods";
    
    public static final String CALL_STACK_LINES = "callStackDumpLineNumbers";
    
    public static final String THREAD_OWNER = "threadOwner";

    public static final String NODE_ID = "nodeId";

    public static final String NODE_ID_REF = "nodeIdRef";

    public static final String HOSTNAME = "hostname";

    public static final String IPADDRESS = "ipaddress";

    public static final String TIMEZONE = "timezone";

    public static final String TIMESTAMP = "timestamp";

    public static final String SIZE = "size";

    public static final String LINE = "line";

    public static final String CONTEXT_DATA = "contextData";
    
    public static final String PROCESS_ID = "processId";
    
    public static final String PID = "pid";
    
    public static final String APPLICATION_EXECUTABLE = "applicationExecutable";


    private BinaryFragmentLoader loader;
	
	private String name;
	
	public BinaryFragmentParser() {
		loader = new IgnoredBinaryFragmentLoader();
	}
	
	protected BinaryFragmentParser(Short id, String name) {
		loader = (BinaryFragmentLoader) LoaderExtensions.getInstance().get(name);
		if (loader == null) {
			System.err.println("Message " + name + " handler is not found - using default");
			loader = new IgnoredBinaryFragmentLoader();
		}
		this.name = name;
	}
	
	public BinaryFragmentLoader getLoader() {
		return loader;
	}
	
	public abstract boolean parse(BinaryFragment fragment, Offset offset, BFReader reader);

	public void addYourselfInContext() {
		loader.addYourselfInContext();
	}

	public void initialize(HierarchyContext context) {
		if (name != null) {
			loader.initialize(context, name);
		}
	}

    protected void addAnnotation(BinaryFragmentLoader loader, Object[] data, String name) {
        loader.startChild(ANNOTATION);
        loader.addAttribute(NAME_ATTR, name);
        for(int i = 0; i < data.length; ++i) {
            char[] charData = data[i].toString().toCharArray();
            loader.startChild(VALUE);
            loader.addCharacters(charData, 0, charData.length);
            loader.endChild(VALUE);
        }
        loader.endChild(ANNOTATION);
    }
}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/IgnoredBinaryFragmentParser.java (+8 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	public class IgnoredBinaryFragmentParser extends BinaryFragmentParser {
4	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
5	System.out.println("Ignored handler was invoked for id [" + fragment.getId() + "]");
6	return true;
7	}
8	}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMonContendedEnteredParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short) 1035);
	
	public static final String NAME = "monContendedEntered"; 

	public BFMonContendedEnteredParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));

		long stackDepth = reader.readUnsignedInt(data, offset);

		String[] stackMethods = reader.readStringArray(data, (int)stackDepth, offset); // Possible truncation
		addAnnotation(loader, stackMethods, CALL_STACK_METHODS);

		Long[] stackLines = reader.readLongArray(data, (int)stackDepth, offset);
		addAnnotation(loader, stackLines, CALL_STACK_LINES);
			
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary;

public class Offset {
	private int offset;
	
	private final long length;
	
	public Offset(int offset, long length) {
		if (offset < 0 || (length > 0 && offset > length)) {
			throw new IllegalArgumentException("Offset should be between 0 and " + length);
		}
		this.offset = offset;
		this.length = length;
	}
	
	public Offset(int offset) {
		this(offset, 0);
	}

	public int increaseOffset(int delta) {
		int oldOffset = offset;
		int newOffset = offset + delta;
		if (length > 0 && newOffset > length) {
			return -1;
		}
		offset = newOffset;
		return oldOffset;
	}
	
	public int getOffset() {
		return offset;
	}
	
	public long getLength() {
		return length;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFRuntimeShutdownParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1031);

	public static final String NAME = "runtimeShutdown";

	public BFRuntimeShutdownParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMonWaitParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1032);

	public static final String NAME = "monWait";

	public BFMonWaitParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(TIMEOUT, reader.readLong(data, offset));

		// stackDepth
		int stackDepth = reader.readInt(data, offset);
		String stackMethods[] = reader.readStringArray(data, stackDepth, offset);
		addAnnotation(loader, stackMethods, CALL_STACK_METHODS);

		Long stackLines[] = reader.readLongArray(data, stackDepth, offset);
		addAnnotation(loader, stackLines, CALL_STACK_LINES);
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFClassUnloadParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1025);

	public static final String NAME = "classUnload";
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary;

import java.io.IOException;

public class BinaryFragment {

	public static final int HEADER_LENGTH = 6;

	Short id;
	
	int length;
	
	byte[] body;
	
	public BinaryFragment(byte[] header, BFReader reader) throws IOException {
		Offset headerMarker = new Offset(0, HEADER_LENGTH);
		this.id = new Short((short)reader.readUnsignedShort(header, headerMarker));
		this.length = (int)reader.readUnsignedInt(header, headerMarker);
	}

	public Short getId() {
		return id;
	}

	public int getLength() {
		return length;
	}

	public byte[] getBody() {
		return body;
	}

	public void setBody(byte[] body) {
		this.body = body;
	}
	
	
}




package org.eclipse.hyades.loaders.util.binary;

public interface NumberReader {
	public short readShort(byte[] b, Offset offset);
	
	public int readUnsignedShort(byte[] b, Offset offset);

	public int readInt(byte[] b, Offset offset);
	
	public long readUnsignedInt(byte[] b, Offset offset);

	public long readLong(byte[] b, Offset offset);
	
	public Long[] readLongArray(byte[] b, int length, Offset offset);

	public void setCpuFrequency(long frequency);
	
	public double readTimestamp(byte[] b, Offset offset);
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFInvocationContextParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1018);

	public static final String NAME = "invocationContext";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {

//		// NodeIdRef ignored
//		reader.readLong(data, offset);
//		// processIdRef ignored
//		reader.readLong(data, offset);
//		// agentIdRef ignored
//		reader.readLong(data, offset);
//		// threadIdRef ignored
//		reader.readLong(data, offset);
//		// ticket ignored
//		reader.readInt(data, offset);
//		// sequenceNumber ignored
//		reader.readLong(data, offset);
//		// colValue ignored
//		reader.readString(data, offset);
//		// traceIdRef ignored
//		reader.readString(data, offset);
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFOptionParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1008);

	public static final String NAME = "option";

	public BFOptionParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		// traceIdRef ignored
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		loader.addAttribute(KEY, reader.readString(data, offset));
		loader.addAttribute(VALUE, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFGCFinishParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1027);

	public static final String NAME = "gcFinish";

	public BFGCFinishParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(TOTAL_OBJECT_SPACE, reader.readLong(data, offset));
		loader.addAttribute(USED_OBJECT_SPACE, reader.readLong(data, offset));
		loader.addAttribute(USED_OBJECTS, reader.readLong(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}

}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/BFParser.java (+7 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	import java.io.InputStream;
4
5	public interface BFParser {
6	public void parseEvents(InputStream inputStream, Offset marker);
7	}




package org.eclipse.hyades.loaders.util.binary;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

import org.eclipse.hyades.loaders.util.InvalidXMLException;
import org.eclipse.hyades.loaders.util.XMLLoader;
import org.eclipse.hyades.models.hierarchy.TRCAgent;
import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;
import org.eclipse.hyades.models.hierarchy.TRCMonitor;
import org.eclipse.hyades.models.hierarchy.util.internal.InvalidEventException;

public class BinaryLoader extends XMLLoader {

	private final BFParserFactory parserFactory = new BFParserFactory();
	
	public BinaryLoader(TRCAgent agent) {
		super(agent);
	}

	public BinaryLoader(TRCAgentProxy agentProxy) {
		super(agentProxy);
	}

	public BinaryLoader(TRCMonitor monitor) {
		super(monitor);
	}

	public void loadEvents(InputStream inputStream, long offset, long length) throws InvalidEventException {

		if (offset > 0) {
			try {
				inputStream.skip(offset);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		Offset marker = new Offset((int)offset, length);

		try {
			BFHeader formatHeader = new BFHeader(inputStream, marker);
			
			BFReader reader = new BFReader();
			formatHeader.visit(reader);
			
			BFParser parser = parserFactory.get(formatHeader, context, reader);
			
			parser.parseEvents(inputStream, marker);
		} catch (Exception e) {
			e.printStackTrace();
			throw new InvalidXMLException(e);
		}
	}
	
	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		FileInputStream inputStream = new FileInputStream(args[0]);
		BinaryLoader loader = new BinaryLoader((TRCAgent)null);
		loader.loadEvents(inputStream, 0, Integer.MAX_VALUE);
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFThreadEndParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1010);

	public static final String NAME = "threadEnd";

	public BFThreadEndParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFAGMethodEntryParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short) 1036);
	
	public static final String NAME = "agMethodEntry"; 

	public BFAGMethodEntryParser() {
		super(ID, NAME);
	}

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(METHOD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(BASE_TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(MIN_TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(MAX_TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(CPU_TIME, reader.readLong(data, offset));
		loader.addAttribute(COUNT, (int)reader.readLong(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFGCRootParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1039);
	
	public static final String NAME = "gcRoot"; 

	public BFGCRootParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(TYPE, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMethodCountParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1021);

	public static final String NAME = "methodCount";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFHeapDumpDefParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short) 1038);
	
	public static final String NAME = "heapDumpDef"; 

	public BFHeapDumpDefParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(HEAP_DUMP_ID_REF, (short) reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(NAME_ATTR, reader.readString(data, offset));
		loader.addAttribute(BASE_TIME, reader.readTimestamp(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFGCStartParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1023);

	public static final String NAME = "gcStart";

	public BFGCStartParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFObjDefParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1019);

	public static final String NAME = "objDef";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {

//		// objId ignored
//		reader.readLong(data, offset);
//		// isArray ignored
//		reader.readByte(data, offset);
//		// size ignored
//		reader.readLong(data, offset);
//		// classIdRef ignored
//		reader.readLong(data, offset);
//		// colValue ignored
//		reader.readString(data, offset);
//		// traceIdRef ignored
//		reader.readString(data, offset);
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFThreadStartParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1009);

	public static final String NAME = "threadStart";

	public BFThreadStartParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		// transThreadId ignored
		loader.addAttribute(TRANS_THREAD_ID, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(GROUP_NAME, reader.readString(data, offset));
		loader.addAttribute(PARENT_NAME, reader.readString(data, offset));
		loader.addAttribute(TRANS_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_NAME, reader.readString(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
			
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFClassDefParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1011);

	public static final String NAME = "classDef";

	public BFClassDefParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(NUM_INTERFACES, reader.readInt(data, offset));
		loader.addAttribute(INTERFACE_NAMES, reader.readString(data, offset));
		loader.addAttribute(TRANS_CLASS_ID, reader.readLong(data, offset));
		loader.addAttribute(CLASS_ID, reader.readLong(data, offset));
		loader.addAttribute(SOURCE_NAME, reader.readString(data, offset));
		loader.addAttribute(CLASS_LOADER, reader.readString(data, offset));
		loader.addAttribute(SUPER_CLASS, reader.readString(data, offset));
		loader.addAttribute(TRANS_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(NAME_ATTR, reader.readString(data, offset));
		loader.addAttribute(ACCESS, reader.readString(data, offset));
		loader.addAttribute(NUM_STATIC_FIELDS, reader.readInt(data, offset));
		loader.addAttribute(NUM_METHODS, reader.readInt(data, offset));
		loader.addAttribute(NUM_INSTANCE_FIELDS, reader.readInt(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFTraceEndParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1006);

	public static final String NAME = "traceEnd";

	public BFTraceEndParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFObjRefParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1040);
	
	public static final String NAME = "objReference"; 

	public BFObjRefParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(OWNER_OBJ_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TARGET_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(HEAP_DUMP_ID_REF, (short) reader.readLong(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFLineParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1022);

	public static final String NAME = "line";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary;

import java.io.UnsupportedEncodingException;

public class BFReader implements NumberReader, StringReader {


	public static final StringReader ASCII_READER = new StringReader() {
			private static final char EOS = '\0';
			
			private static final String DEFAULT_ENCODING = "UTF-8";

			private String encoding = DEFAULT_ENCODING;
			
			public void setEncoding(String encoding) {
				this.encoding = encoding;
			}

			public String readString(byte[] b, Offset offset) {
				int start = offset.getOffset();
				int end = -1;
				for(int i = start; i < b.length; ++i) {
					char c = (char) b[i];
					if (c == EOS) {
						end = i;
						break;
					}
				}
				
				if (end >= 0) {
					int stringOffset = (end - start) + 1;
					if (offset.increaseOffset(stringOffset) < 0) {
						return null;
					}
					
					try {
						return new String(b, start, stringOffset - 1, encoding);
					} catch (UnsupportedEncodingException e) {
						setEncoding(DEFAULT_ENCODING);
						return  new String(b, start, stringOffset - 1);
					}
				}
				return null;
			}

			public String[] readStringArray(byte[] b, int length, Offset offset) {
				String[] res = new String[length];
				for (int i = 0; i < length; ++i) {
					res[i] = readString(b, offset);
				}
				return res;
			}

		};
	
	public static final NumberReader LE_64_READER = new NumberReader() { // Little-endian, IA64

			private long cpuFrequency;
			
			public short readShort(byte[] b, Offset offset) {
				int start = offset.getOffset();
		        if (offset.increaseOffset(2) < 0) {
		        	return 0;
		        }
		        int ch1 = b[start];
		        int ch2 = b[start + 1];
		        
		        return (short)((ch2 << 8) + (ch1 << 0));			
			} 
			
			public int readUnsignedShort(byte[] b, Offset offset) {
				int start = offset.getOffset();
		        if (offset.increaseOffset(2) < 0) {
		        	return 0;
		        }
		        int ch1 = b[start] & 0xFF;
		        int ch2 = b[start + 1] & 0xFF;
		        
		        return ((ch2 << 8) + (ch1 << 0));			
			}

			public int readInt(byte[] b, Offset offset) {
				int start = offset.getOffset();
				if (offset.increaseOffset(4) < 0) {
					return 0;
				}
		        int ch1 = b[start];
		        int ch2 = b[start + 1];
		        int ch3 = b[start + 2];
		        int ch4 = b[start + 3];
		        
		        return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
			}
		
			public long readUnsignedInt(byte[] b, Offset offset) {
				int start = offset.getOffset();
				if (offset.increaseOffset(4) < 0) {
					return 0;
				}
		        int ch1 = b[start] & 0xFF;
		        int ch2 = b[start + 1] & 0xFF;
		        int ch3 = b[start + 2] & 0xFF;
		        int ch4 = b[start + 3] & 0xFF;
		        
		        return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 >> 0));
			}

			public long readLong(byte[] b, Offset offset) {
				int start = offset.getOffset();
				if (offset.increaseOffset(8) < 0) {
					return 0;
				}
		        int ch1 = b[start];
		        int ch2 = b[start + 1];
		        int ch3 = b[start + 2];
		        int ch4 = b[start + 3];
		        int ch5 = b[start + 4];
		        int ch6 = b[start + 5];
		        int ch7 = b[start + 6];
		        int ch8 = b[start + 7];
		        
		        return (((long)ch8 << 56) + ((long)(ch7 & 255) << 48) + ((long)(ch6 & 255) << 40) + ((long)(ch5 & 255) << 32) +
		                ((long)(ch4 & 255) << 24) + ((ch3 & 255) << 16) + ((ch2 & 255) <<  8) + ((ch1 & 255) <<  0));
	        }

			public Long[] readLongArray(byte[] b, int length, Offset offset) {
				Long[] res = new Long[length];
				for (int i = 0; i < length; ++i) {
					res[i] = new Long(readLong(b, offset));
				}
				return res;
			}

			public void setCpuFrequency(long frequency) {
				this.cpuFrequency = frequency;
			}

			public double readTimestamp(byte[] b, Offset offset) {
				long value = readLong(b, offset);
				
				if (cpuFrequency > 0) {
					value /= cpuFrequency;
				}
				
		    	double high = (value / 1000000000);
		    	double low = (value % 1000000000) * 0.000000001;
		    	double result = high + low;

		    	return result;
			}

		};
	
	private NumberReader numberReader;
	
	private StringReader stringReader;

	public BFReader(NumberReader numberReader, StringReader stringReader) {
		this.numberReader = numberReader;
		this.stringReader = stringReader;
	}
	
	public BFReader() {
		this(LE_64_READER, ASCII_READER);
	}

	public NumberReader getNumberReader() {
		return numberReader;
	}

	public void setNumberReader(NumberReader numberReader) {
		this.numberReader = numberReader;
	}

	public StringReader getStringReader() {
		return stringReader;
	}

	public void setStringReader(StringReader stringReader) {
		this.stringReader = stringReader;
	}

	public String readString(byte[] b, Offset offset) {
		return stringReader.readString(b, offset);
	}
	
	public String[] readStringArray(byte[] b, int length, Offset offset) {
		return stringReader.readStringArray(b, length, offset);
	}

	public byte readByte(byte[] b, Offset offset) {
		int start = offset.getOffset();
		if (offset.increaseOffset(1) < 0) {
			return 0;
		}
		return b[start];
	}

	public short readShort(byte[] b, Offset offset) {
		return numberReader.readShort(b, offset);
	}

	public int readUnsignedShort(byte[] b, Offset offset) {
		return numberReader.readUnsignedShort(b, offset);
	}

	public int readInt(byte[] b, Offset offset) {
		return numberReader.readInt(b, offset);
	}

	public long readUnsignedInt(byte[] b, Offset offset) {
		return numberReader.readUnsignedInt(b, offset);
	}

	public long readLong(byte[] b, Offset offset) {
		return numberReader.readLong(b, offset);
	}

	public Long[] readLongArray(byte[] b, int length, Offset offset) {
		return numberReader.readLongArray(b, length, offset);
	}

	public double readTimestamp(byte[] b, Offset offset) {
		return numberReader.readTimestamp(b, offset);
	}

	public void setCpuFrequency(long frequency) {
		numberReader.setCpuFrequency(frequency);
	}

	public void setEncoding(String encoding) {
		stringReader.setEncoding(encoding);
	}
}




package org.eclipse.hyades.loaders.util.binary;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

public class BFHeader {
	
	public static final int LENGTH = 12;
	
	private Magic magic;
	
	private Version version;

	private Platform platform;
	
	private Endianness endianness;

	public BFHeader(InputStream inputStream, Offset offset) throws IOException {
		Offset marker = new Offset(0, LENGTH);
		byte[] header = new byte[LENGTH];

		if (inputStream.read(header) < 0) {
			throw new IllegalArgumentException("Malformed header");
		}
		// indent is ignored
		marker.increaseOffset(1);
		magic = Magic.read(header, marker);
		if (magic == null) {
			throw new IllegalArgumentException("Format is not supported");
		}
		version = Version.read(header, marker);
		if (version == null) {
			throw new IllegalArgumentException("Version is not supported");
		}
		platform = Platform.read(header, marker);
		if (platform == null) {
			throw new IllegalArgumentException("Platform is not supported");
		}
		endianness = Endianness.read(header, marker);
		if (endianness == null) {
			throw new IllegalArgumentException("Endianness is not supported");
		}
		// offset to data is ignored at the moment
		
		offset.increaseOffset(LENGTH);
	}

	public Magic getMagic() {
		return magic;
	}

	public Platform getPlatform() {
		return platform;
	}

	public Endianness getEndianness() {
		return endianness;
	}

	public Version getVersion() {
		return version;
	}

	public BFReader visit(BFReader reader) {
		if (Platform.IA32.equals(platform) && Endianness.LITTLE_ENDIAN.equals(endianness)) {
			reader.setNumberReader(BFReader.LE_64_READER);
		} else if (Platform.IA64.equals(platform) && Endianness.LITTLE_ENDIAN.equals(endianness)) {
			reader.setNumberReader(BFReader.LE_64_READER);
		}
		
		return reader;
	}
	
	public static class Magic {

		private static Map entries = new HashMap();
		
		public static int LENGTH = 3;
		
		public static final Magic TBF_INDENT = new Magic("TBF");
			
		private final String magic;
		
		public Magic(String magic) {
			this.magic = magic;
			entries.put(magic, this);
		}

		public String getMagic() {
			return magic;
		}
		
		public static Magic read(byte[] header, Offset offset) {
			String magic = new String(header, offset.increaseOffset(LENGTH), LENGTH);
			return (Magic) entries.get(magic);
		}
	}
	
	public static class Platform {

		private static Map entries = new HashMap();
		
		public static final Platform IA32 = new Platform(0);

		public static final Platform IA64 = new Platform(1);
		

		private final int code;
		
		public Platform(int code) {
			this.code = code;
			entries.put(new Integer(code), this);
		}

		public int getCode() {
			return code;
		}

		public static Platform read(byte[] header, Offset offset) {
			int code = header[offset.increaseOffset(1)];
			return (Platform) entries.get(new Integer(code));
		}
	}
	
	public static class Endianness {
		private static Map entries = new HashMap();

		public static final Endianness BIG_ENDIAN = new Endianness(0);
		
		public static final Endianness LITTLE_ENDIAN = new Endianness(1);

		private final int code;
		
		public Endianness(int code) {
			this.code = code;
			entries.put(new Integer(code), this);
		}

		public int getCode() {
			return code;
		}
		
		public static Endianness read(byte[] header, Offset offset) {
			int code = header[offset.increaseOffset(1)];
			return (Endianness) entries.get(new Integer(code));
		}
	}
	
	public static class Version {
		private static Map entries = new HashMap();

		public static final Version VERSION_1_0 = new Version(1.0);
		
		private final double version;
		
		public Version(double version) {
			this.version = version;
			entries.put(new Double(version), this);
		}

		public double getVersion() {
			return version;
		}

		public static Version read(byte[] header, Offset offset) {
			int major = header[offset.increaseOffset(1)];
			int minor = header[offset.increaseOffset(1)];
			double ver = major + (minor * 0.1);
			return (Version) entries.get(new Double(ver));
		}
	}
	
	public static class Encoding {
		private static Map entries = new HashMap();

		public static final Encoding UTF8 = new Encoding(0);
		
		public static final Encoding ASCII = new Encoding(1);

		private final int code;
		
		public Encoding(int code) {
			this.code = code;
			entries.put(new Integer(code), this);
		}

		public int getCode() {
			return code;
		}
		
		public static Encoding read(byte[] header, Offset offset) {
			int code = header[offset.increaseOffset(1)];
			return (Encoding) entries.get(new Integer(code));
		}
	}
}




package org.eclipse.hyades.loaders.util.binary;

import org.eclipse.hyades.loaders.util.XMLFragmentLoader;

public interface BinaryFragmentLoader extends XMLFragmentLoader {
	public void addAttribute(String name, byte value);

	public void addAttribute(String name, short value);

	public void addAttribute(String name, int value);

	public void addAttribute(String name, long value);

	public void addAttribute(String name, double value);
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFProcessCreateParser extends BinaryFragmentParser {
	public static final Short ID = new Short((short)1002);

	public static final String NAME = "processCreate";

	public BFProcessCreateParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(PROCESS_ID, reader.readString(data, offset));
		loader.addAttribute(NAME_ATTR, reader.readString(data, offset));
		loader.addAttribute(PID, reader.readInt(data, offset));
		loader.addAttribute(NODE_ID_REF, reader.readString(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(APPLICATION_EXECUTABLE, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMethodDefParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1012);

	public static final String NAME = "methodDef";

	public BFMethodDefParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();


		loader.addAttribute(NAME_ATTR, reader.readString(data, offset));
		loader.addAttribute(SIGNATURE, reader.readString(data, offset));
		loader.addAttribute(VISIBILITY, reader.readString(data, offset));
		loader.addAttribute(IS_NATIVE, reader.readByte(data, offset));
		loader.addAttribute(IS_ABSTRACT, reader.readByte(data, offset));
		loader.addAttribute(IS_STATIC, reader.readByte(data, offset));
		loader.addAttribute(IS_SYNCHRONIZED, reader.readByte(data, offset));
		loader.addAttribute(EXCEPTIONS, reader.readString(data, offset));
		loader.addAttribute(START_LINE_NUMBER, (int) reader.readLong(data, offset));
		loader.addAttribute(END_LINE_NUMBER, (int) reader.readLong(data, offset));
		loader.addAttribute(SIGNATURE_NOTATION, reader.readString(data, offset));
		loader.addAttribute(TRANS_CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(METHOD_ID, (int)reader.readLong(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFTraceStartParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1005);

	public static final String NAME = "traceStart";

	public BFTraceStartParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRACE_ID, reader.readString(data, offset));
		loader.addAttribute(AGENT_ID_REF, reader.readString(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFObjMoveParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1026);

	public static final String NAME = "objMove";

	public BFObjMoveParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFThrowParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1028);

	public static final String NAME = "throw";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFObjFreeParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1024);

	public static final String NAME = "objFree";

	public BFObjFreeParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(TRANS_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_AGE, reader.readLong(data, offset));
		loader.addAttribute(SEQUENCE_COUNTER, reader.readLong(data, offset));
		loader.addAttribute(STACK_DEPTH, reader.readLong(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}

}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFNodeParser extends BinaryFragmentParser {
	
	public static final Short ID = new Short((short)1001);

	public static final String NAME = "node";

	public BFNodeParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(NODE_ID, reader.readString(data, offset));
		loader.addAttribute(HOSTNAME, reader.readString(data, offset));
		loader.addAttribute(IPADDRESS, reader.readString(data, offset));
		loader.addAttribute(TIMEZONE, reader.readTimestamp(data, offset));
		loader.addAttribute(TIMESTAMP, reader.readLong(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFRuntimeInitDoneParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1030);

	public static final String NAME = "runtimeInitDone";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		// ignored!
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMonWaitedParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1033);

	public static final String NAME = "monWaited";

	public BFMonWaitedParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(TIMEOUT, reader.readLong(data, offset));
		// stackDepth
		int stackDepth = reader.readInt(data, offset);
		String stackMethods[] = reader.readStringArray(data, stackDepth, offset);
		addAnnotation(loader, stackMethods, CALL_STACK_METHODS);

		Long stackLines[] = reader.readLongArray(data, stackDepth, offset);
		addAnnotation(loader, stackLines, CALL_STACK_LINES);
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFAGMethodExitParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short) 1037);
	
	public static final String NAME = "agMethodExit"; 

	public BFAGMethodExitParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(METHOD_ID_REF, (int) reader.readLong(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMethodEntryParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1014);

	public static final String NAME = "methodEntry";

	public BFMethodEntryParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(METHOD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TICKET, reader.readLong(data, offset));
		loader.addAttribute(TRANS_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_CPU_TIME, reader.readLong(data, offset));
		loader.addAttribute(SEQUENCE_COUNTER, reader.readLong(data, offset));
		loader.addAttribute(STACK_DEPTH, (short) reader.readLong(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary;

import java.util.HashMap;
import java.util.Map;

import org.eclipse.hyades.loaders.util.HierarchyContext;
import org.eclipse.hyades.loaders.util.binary.v1_0.ParserImpl1_0;

public class BFParserFactory {
	private static final Class[] constructorArgs = new Class[] {HierarchyContext.class, BFReader.class};
	
	private final Map parsers = new HashMap();
	
	public BFParserFactory() {
		ParserImpl1_0.register(this);
	}
	
	public BFParser get(BFHeader header, HierarchyContext context, BFReader reader) {
		Class parserClass = (Class) parsers.get(new Double(header.getVersion().getVersion()));
		if (parserClass == null) {
			return null;
		}
			
		try {
			return (BFParser) parserClass.getConstructor(constructorArgs).newInstance(new Object[] {context, reader});
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		
		return null;
	}

	public void put(Double version, Class parser) {
		parsers.put(version, parser);
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFMethodExitParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1015);

	public static final String NAME = "methodExit";

	public BFMethodExitParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(TICKET, reader.readLong(data, offset));
		loader.addAttribute(THREAD_CPU_TIME, reader.readLong(data, offset));
		loader.addAttribute(METHOD_ID_REF, (int) reader.readLong(data, offset));
		loader.addAttribute(TRANS_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(TRANS_CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(SEQUENCE_COUNTER, reader.readLong(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFAgentDestroyParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1004);

	public static final String NAME = "agentDestroy";

	public BFAgentDestroyParser() {
		super(ID, NAME);
	}

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(AGENT_ID_REF, reader.readString(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		
		return true;
	}

}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/StringReader.java (+9 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	public interface StringReader {
4	public void setEncoding(String encoding);
5
6	public String readString(byte[] b, Offset offset);
7
8	public String[] readStringArray(byte[] b, int length, Offset offset);
9	}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFObjAllocParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1013);

	public static final String NAME = "objAlloc";

	public BFObjAllocParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRANS_THREAD_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(THREAD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TIME, reader.readTimestamp(data, offset));
		loader.addAttribute(IS_ARRAY, reader.readByte(data, offset));
		loader.addAttribute(TRANS_OBJ_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(OBJ_ID, reader.readLong(data, offset));
		loader.addAttribute(SIZE, (int) reader.readLong(data, offset));
		loader.addAttribute(LINE, (int) reader.readLong(data, offset));
		loader.addAttribute(METHOD_ID_REF, (int)reader.readLong(data, offset));
		loader.addAttribute(TRANS_CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(CLASS_ID_REF, reader.readLong(data, offset));
		loader.addAttribute(CONTEXT_DATA, reader.readString(data, offset));
		loader.addAttribute(COLLATION_VALUE, reader.readString(data, offset));
		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		
		return true;
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.hyades.loaders.util.HierarchyContext;
import org.eclipse.hyades.loaders.util.binary.BFParser;
import org.eclipse.hyades.loaders.util.binary.BFParserFactory;
import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class ParserImpl1_0 implements BFParser {
	
	public static final Double version = new Double(1.0);
	
	// ID (Short) -> Class (class)
	Map messageHandlers = new HashMap();
	
	private final HierarchyContext context;
	
	private final BFReader reader;
	
	public ParserImpl1_0(HierarchyContext context, BFReader reader) {
		this.context = context;
		this.reader = reader;
		initialize();
	}

	protected void initialize() {
		// System handlers 0-1000
		
		// Data handlers 1000-32767
		messageHandlers.put(BFNodeParser.ID, BFNodeParser.class);
		messageHandlers.put(BFProcessCreateParser.ID, BFProcessCreateParser.class);
		messageHandlers.put(BFAgentCreateParser.ID, BFAgentCreateParser.class);
		messageHandlers.put(BFAgentDestroyParser.ID, BFAgentDestroyParser.class);
		messageHandlers.put(BFTraceStartParser.ID, BFTraceStartParser.class);
		messageHandlers.put(BFTraceEndParser.ID, BFTraceEndParser.class);
		messageHandlers.put(BFFilterParser.ID, BFFilterParser.class);
		messageHandlers.put(BFOptionParser.ID, BFOptionParser.class);
		messageHandlers.put(BFThreadStartParser.ID, BFThreadStartParser.class);
		messageHandlers.put(BFThreadEndParser.ID, BFThreadEndParser.class);
		messageHandlers.put(BFClassDefParser.ID, BFClassDefParser.class);
		messageHandlers.put(BFMethodDefParser.ID, BFMethodDefParser.class);
		messageHandlers.put(BFObjAllocParser.ID, BFObjAllocParser.class);
		messageHandlers.put(BFMethodEntryParser.ID, BFMethodEntryParser.class);
		messageHandlers.put(BFMethodExitParser.ID, BFMethodExitParser.class);
		// Method call ignored
		// Method exit ignored
		messageHandlers.put(BFInvocationContextParser.ID, BFInvocationContextParser.class);
		messageHandlers.put(BFObjDefParser.ID, BFObjDefParser.class);
		messageHandlers.put(BFValueParser.ID, BFValueParser.class);
		messageHandlers.put(BFMethodCountParser.ID, BFMethodCountParser.class);
		messageHandlers.put(BFLineParser.ID, BFLineParser.class);
		messageHandlers.put(BFGCStartParser.ID, BFGCStartParser.class);
		messageHandlers.put(BFObjFreeParser.ID, BFObjFreeParser.class);
		messageHandlers.put(BFClassUnloadParser.ID, BFClassUnloadParser.class);
		messageHandlers.put(BFObjMoveParser.ID, BFObjMoveParser.class);
		messageHandlers.put(BFGCFinishParser.ID, BFGCFinishParser.class);
		messageHandlers.put(BFThrowParser.ID, BFThrowParser.class);
		messageHandlers.put(BFCatchParser.ID, BFCatchParser.class);
		messageHandlers.put(BFRuntimeInitDoneParser.ID, BFRuntimeInitDoneParser.class);
		messageHandlers.put(BFRuntimeShutdownParser.ID, BFRuntimeShutdownParser.class);
		messageHandlers.put(BFMonWaitParser.ID, BFMonWaitParser.class);
		messageHandlers.put(BFMonWaitedParser.ID, BFMonWaitedParser.class);
		messageHandlers.put(BFMonContendedEnterParser.ID, BFMonContendedEnterParser.class);
		messageHandlers.put(BFMonContendedEnteredParser.ID, BFMonContendedEnteredParser.class);
		messageHandlers.put(BFAGMethodEntryParser.ID, BFAGMethodEntryParser.class);
		messageHandlers.put(BFAGMethodExitParser.ID, BFAGMethodExitParser.class);
		messageHandlers.put(BFHeapDumpDefParser.ID, BFHeapDumpDefParser.class);
		messageHandlers.put(BFGCRootParser.ID, BFGCRootParser.class);
		messageHandlers.put(BFObjRefParser.ID, BFObjRefParser.class);
	}
	
	public void parseEvents(InputStream inputStream, Offset marker) {
		try {
			do {
				byte[] header = new byte[BinaryFragment.HEADER_LENGTH];
				if (inputStream.read(header) < 0) {
					break;
				}
				BinaryFragment binaryFragment = new BinaryFragment(header, reader);
				marker.increaseOffset(BinaryFragment.HEADER_LENGTH);

				byte[] body = new byte[binaryFragment.getLength()];
				if(inputStream.read(body) < 0) {
					break;
				}

				binaryFragment.setBody(body);
				marker.increaseOffset(binaryFragment.getLength());

				if (binaryFragment.getId() == null) {
					System.out.println("Hell no! Unparseable event!");
					continue;
				}
				BinaryFragmentParser fragmentParser = getFragmentParser(binaryFragment.getId());
				
				if (fragmentParser.getClass().equals(IgnoredBinaryFragmentParser.class)) {
					System.out.println("Got unknown message at " + marker.getOffset());
				}

				fragmentParser.initialize(context);
				if (fragmentParser.parse(binaryFragment, new Offset(0, binaryFragment.getBody().length), reader)) {
					fragmentParser.addYourselfInContext();
				}
			} while (true);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

	protected BinaryFragmentParser getFragmentParser(Short id) throws InstantiationException, IllegalAccessException {
		Class clazz = (Class) messageHandlers.get(id);
		
		BinaryFragmentParser fragmentParser = (BinaryFragmentParser) clazz.newInstance();
		if (fragmentParser == null) {
			return new IgnoredBinaryFragmentParser();
		}
		
		return fragmentParser; 
	}

	public static void register(BFParserFactory parserFactory) {
		parserFactory.put(version, ParserImpl1_0.class);
	}
}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFFilterParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short)1007);

	public static final String NAME = "filter";

	public BFFilterParser() {
		super(ID, NAME);
	}
	
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		BinaryFragmentLoader loader = getLoader();

		loader.addAttribute(TRACE_ID_REF, reader.readString(data, offset));
		loader.addAttribute(PATTERN, reader.readString(data, offset));
		loader.addAttribute(GENERIC_PATTERN, reader.readString(data, offset));
		loader.addAttribute(MODE, reader.readString(data, offset));
		loader.addAttribute(METHOD_PATTERN, reader.readString(data, offset));
		loader.addAttribute(METHOD_GENERIC_PATTERN, reader.readString(data, offset));
		loader.addAttribute(METHOD_MODE, reader.readString(data, offset));
		
		return true;
	}


}




package org.eclipse.hyades.loaders.util.binary.v1_0;

import org.eclipse.hyades.loaders.util.binary.BFReader;
import org.eclipse.hyades.loaders.util.binary.BinaryFragment;
import org.eclipse.hyades.loaders.util.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.util.binary.Offset;

public class BFCatchParser extends IgnoredBinaryFragmentParser {

	public static final Short ID = new Short((short)1029);

	public static final String NAME = "catch";

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		return true;
	}
}

Return to bug 209343

Lines 13-24 Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/hierarchy/IgnoredXMLFragmentLoader.java (-2 / +28 lines)
13		13
14	import org.eclipse.hyades.loaders.util.HierarchyContext;	14	import org.eclipse.hyades.loaders.util.HierarchyContext;
15	import org.eclipse.hyades.loaders.util.XMLFragmentLoader;	15	import org.eclipse.hyades.loaders.util.XMLFragmentLoader;
		16	import org.eclipse.hyades.loaders.util.binary.BinaryFragmentLoader;
16		17
17		18
18	/**	19	/**
19	* @author slavescu	20	* @author slavescu
20	*/	21	*/
21	public class IgnoredXMLFragmentLoader implements XMLFragmentLoader {	22	public class IgnoredXMLFragmentLoader implements XMLFragmentLoader, BinaryFragmentLoader {
22	//~ Instance fields ----------------------------------------------------------------------------	23	//~ Instance fields ----------------------------------------------------------------------------
23		24
24	protected HierarchyContext context;	25	protected HierarchyContext context;
Lines 29-35 Link Here
29	// do nothing	30	// do nothing
30	}	31	}
31		32
32	public void addCharacters(char[] data, int offset, int length) {	33	/**
		34	* Inefficient, pilot version.
		35	* TODO These methods should invoke real setters w/o toString conversion.
		36	*/
		37	public void addAttribute(String name, byte value) {
		38	addAttribute(name, new Byte(value).toString());
		39	}
		40
		41	public void addAttribute(String name, short value) {
		42	addAttribute(name, new Short(value).toString());
		43	}
		44
		45	public void addAttribute(String name, int value) {
		46	addAttribute(name, new Integer(value).toString());
		47	}
		48
		49	public void addAttribute(String name, long value) {
		50	addAttribute(name, new Long(value).toString());
		51	}
		52
		53	public void addAttribute(String name, double value) {
		54	addAttribute(name, new Double(value).toString());
		55	}
		56
		57	public void addCharacters(char[] data, int offset, int length) {
33	// do nothing	58	// do nothing
34	}	59	}
35		60
Lines 52-55 Link Here
52	public void startChild(String name) {	77	public void startChild(String name) {
53	// do nothing	78	// do nothing
54	}	79	}
		80
55	}	81	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/IgnoredBinaryFragmentLoader.java (+22 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	import org.eclipse.hyades.loaders.hierarchy.IgnoredXMLFragmentLoader;
4
5	public class IgnoredBinaryFragmentLoader extends IgnoredXMLFragmentLoader implements BinaryFragmentLoader {
6
7	public void addAttribute(String name, byte value) {
8	}
9
10	public void addAttribute(String name, short value) {
11	}
12
13	public void addAttribute(String name, int value) {
14	}
15
16	public void addAttribute(String name, long value) {
17	}
18
19	public void addAttribute(String name, double value) {
20	}
21
22	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/Offset.java (+37 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	public class Offset {
4	private int offset;
5
6	private final long length;
7
8	public Offset(int offset, long length) {
9	if (offset < 0 \|\| (length > 0 && offset > length)) {
10	throw new IllegalArgumentException("Offset should be between 0 and " + length);
11	}
12	this.offset = offset;
13	this.length = length;
14	}
15
16	public Offset(int offset) {
17	this(offset, 0);
18	}
19
20	public int increaseOffset(int delta) {
21	int oldOffset = offset;
22	int newOffset = offset + delta;
23	if (length > 0 && newOffset > length) {
24	return -1;
25	}
26	offset = newOffset;
27	return oldOffset;
28	}
29
30	public int getOffset() {
31	return offset;
32	}
33
34	public long getLength() {
35	return length;
36	}
37	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/BinaryFragment.java (+38 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	import java.io.IOException;
4
5	public class BinaryFragment {
6
7	public static final int HEADER_LENGTH = 6;
8
9	Short id;
10
11	int length;
12
13	byte[] body;
14
15	public BinaryFragment(byte[] header, BFReader reader) throws IOException {
16	Offset headerMarker = new Offset(0, HEADER_LENGTH);
17	this.id = new Short((short)reader.readUnsignedShort(header, headerMarker));
18	this.length = (int)reader.readUnsignedInt(header, headerMarker);
19	}
20
21	public Short getId() {
22	return id;
23	}
24
25	public int getLength() {
26	return length;
27	}
28
29	public byte[] getBody() {
30	return body;
31	}
32
33	public void setBody(byte[] body) {
34	this.body = body;
35	}
36
37
38	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/NumberReader.java (+19 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	public interface NumberReader {
4	public short readShort(byte[] b, Offset offset);
5
6	public int readUnsignedShort(byte[] b, Offset offset);
7
8	public int readInt(byte[] b, Offset offset);
9
10	public long readUnsignedInt(byte[] b, Offset offset);
11
12	public long readLong(byte[] b, Offset offset);
13
14	public Long[] readLongArray(byte[] b, int length, Offset offset);
15
16	public void setCpuFrequency(long frequency);
17
18	public double readTimestamp(byte[] b, Offset offset);
19	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/BinaryLoader.java (+66 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	import java.io.FileInputStream;
4	import java.io.IOException;
5	import java.io.InputStream;
6
7	import org.eclipse.hyades.loaders.util.InvalidXMLException;
8	import org.eclipse.hyades.loaders.util.XMLLoader;
9	import org.eclipse.hyades.models.hierarchy.TRCAgent;
10	import org.eclipse.hyades.models.hierarchy.TRCAgentProxy;
11	import org.eclipse.hyades.models.hierarchy.TRCMonitor;
12	import org.eclipse.hyades.models.hierarchy.util.internal.InvalidEventException;
13
14	public class BinaryLoader extends XMLLoader {
15
16	private final BFParserFactory parserFactory = new BFParserFactory();
17
18	public BinaryLoader(TRCAgent agent) {
19	super(agent);
20	}
21
22	public BinaryLoader(TRCAgentProxy agentProxy) {
23	super(agentProxy);
24	}
25
26	public BinaryLoader(TRCMonitor monitor) {
27	super(monitor);
28	}
29
30	public void loadEvents(InputStream inputStream, long offset, long length) throws InvalidEventException {
31
32	if (offset > 0) {
33	try {
34	inputStream.skip(offset);
35	} catch (IOException e) {
36	e.printStackTrace();
37	}
38	}
39	Offset marker = new Offset((int)offset, length);
40
41	try {
42	BFHeader formatHeader = new BFHeader(inputStream, marker);
43
44	BFReader reader = new BFReader();
45	formatHeader.visit(reader);
46
47	BFParser parser = parserFactory.get(formatHeader, context, reader);
48
49	parser.parseEvents(inputStream, marker);
50	} catch (Exception e) {
51	e.printStackTrace();
52	throw new InvalidXMLException(e);
53	}
54	}
55
56	/**
57	* @param args
58	* @throws Exception
59	*/
60	public static void main(String[] args) throws Exception {
61	FileInputStream inputStream = new FileInputStream(args[0]);
62	BinaryLoader loader = new BinaryLoader((TRCAgent)null);
63	loader.loadEvents(inputStream, 0, Integer.MAX_VALUE);
64	}
65
66	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/BFReader.java (+234 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	import java.io.UnsupportedEncodingException;
4
5	public class BFReader implements NumberReader, StringReader {
6
7
8	public static final StringReader ASCII_READER = new StringReader() {
9	private static final char EOS = '\0';
10
11	private static final String DEFAULT_ENCODING = "UTF-8";
12
13	private String encoding = DEFAULT_ENCODING;
14
15	public void setEncoding(String encoding) {
16	this.encoding = encoding;
17	}
18
19	public String readString(byte[] b, Offset offset) {
20	int start = offset.getOffset();
21	int end = -1;
22	for(int i = start; i < b.length; ++i) {
23	char c = (char) b[i];
24	if (c == EOS) {
25	end = i;
26	break;
27	}
28	}
29
30	if (end >= 0) {
31	int stringOffset = (end - start) + 1;
32	if (offset.increaseOffset(stringOffset) < 0) {
33	return null;
34	}
35
36	try {
37	return new String(b, start, stringOffset - 1, encoding);
38	} catch (UnsupportedEncodingException e) {
39	setEncoding(DEFAULT_ENCODING);
40	return new String(b, start, stringOffset - 1);
41	}
42	}
43	return null;
44	}
45
46	public String[] readStringArray(byte[] b, int length, Offset offset) {
47	String[] res = new String[length];
48	for (int i = 0; i < length; ++i) {
49	res[i] = readString(b, offset);
50	}
51	return res;
52	}
53
54	};
55
56	public static final NumberReader LE_64_READER = new NumberReader() { // Little-endian, IA64
57
58	private long cpuFrequency;
59
60	public short readShort(byte[] b, Offset offset) {
61	int start = offset.getOffset();
62	if (offset.increaseOffset(2) < 0) {
63	return 0;
64	}
65	int ch1 = b[start];
66	int ch2 = b[start + 1];
67
68	return (short)((ch2 << 8) + (ch1 << 0));
69	}
70
71	public int readUnsignedShort(byte[] b, Offset offset) {
72	int start = offset.getOffset();
73	if (offset.increaseOffset(2) < 0) {
74	return 0;
75	}
76	int ch1 = b[start] & 0xFF;
77	int ch2 = b[start + 1] & 0xFF;
78
79	return ((ch2 << 8) + (ch1 << 0));
80	}
81
82	public int readInt(byte[] b, Offset offset) {
83	int start = offset.getOffset();
84	if (offset.increaseOffset(4) < 0) {
85	return 0;
86	}
87	int ch1 = b[start];
88	int ch2 = b[start + 1];
89	int ch3 = b[start + 2];
90	int ch4 = b[start + 3];
91
92	return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 << 0));
93	}
94
95	public long readUnsignedInt(byte[] b, Offset offset) {
96	int start = offset.getOffset();
97	if (offset.increaseOffset(4) < 0) {
98	return 0;
99	}
100	int ch1 = b[start] & 0xFF;
101	int ch2 = b[start + 1] & 0xFF;
102	int ch3 = b[start + 2] & 0xFF;
103	int ch4 = b[start + 3] & 0xFF;
104
105	return ((ch4 << 24) + (ch3 << 16) + (ch2 << 8) + (ch1 >> 0));
106	}
107
108	public long readLong(byte[] b, Offset offset) {
109	int start = offset.getOffset();
110	if (offset.increaseOffset(8) < 0) {
111	return 0;
112	}
113	int ch1 = b[start];
114	int ch2 = b[start + 1];
115	int ch3 = b[start + 2];
116	int ch4 = b[start + 3];
117	int ch5 = b[start + 4];
118	int ch6 = b[start + 5];
119	int ch7 = b[start + 6];
120	int ch8 = b[start + 7];
121
122	return (((long)ch8 << 56) + ((long)(ch7 & 255) << 48) + ((long)(ch6 & 255) << 40) + ((long)(ch5 & 255) << 32) +
123	((long)(ch4 & 255) << 24) + ((ch3 & 255) << 16) + ((ch2 & 255) << 8) + ((ch1 & 255) << 0));
124	}
125
126	public Long[] readLongArray(byte[] b, int length, Offset offset) {
127	Long[] res = new Long[length];
128	for (int i = 0; i < length; ++i) {
129	res[i] = new Long(readLong(b, offset));
130	}
131	return res;
132	}
133
134	public void setCpuFrequency(long frequency) {
135	this.cpuFrequency = frequency;
136	}
137
138	public double readTimestamp(byte[] b, Offset offset) {
139	long value = readLong(b, offset);
140
141	if (cpuFrequency > 0) {
142	value /= cpuFrequency;
143	}
144
145	double high = (value / 1000000000);
146	double low = (value % 1000000000) * 0.000000001;
147	double result = high + low;
148
149	return result;
150	}
151
152	};
153
154	private NumberReader numberReader;
155
156	private StringReader stringReader;
157
158	public BFReader(NumberReader numberReader, StringReader stringReader) {
159	this.numberReader = numberReader;
160	this.stringReader = stringReader;
161	}
162
163	public BFReader() {
164	this(LE_64_READER, ASCII_READER);
165	}
166
167	public NumberReader getNumberReader() {
168	return numberReader;
169	}
170
171	public void setNumberReader(NumberReader numberReader) {
172	this.numberReader = numberReader;
173	}
174
175	public StringReader getStringReader() {
176	return stringReader;
177	}
178
179	public void setStringReader(StringReader stringReader) {
180	this.stringReader = stringReader;
181	}
182
183	public String readString(byte[] b, Offset offset) {
184	return stringReader.readString(b, offset);
185	}
186
187	public String[] readStringArray(byte[] b, int length, Offset offset) {
188	return stringReader.readStringArray(b, length, offset);
189	}
190
191	public byte readByte(byte[] b, Offset offset) {
192	int start = offset.getOffset();
193	if (offset.increaseOffset(1) < 0) {
194	return 0;
195	}
196	return b[start];
197	}
198
199	public short readShort(byte[] b, Offset offset) {
200	return numberReader.readShort(b, offset);
201	}
202
203	public int readUnsignedShort(byte[] b, Offset offset) {
204	return numberReader.readUnsignedShort(b, offset);
205	}
206
207	public int readInt(byte[] b, Offset offset) {
208	return numberReader.readInt(b, offset);
209	}
210
211	public long readUnsignedInt(byte[] b, Offset offset) {
212	return numberReader.readUnsignedInt(b, offset);
213	}
214
215	public long readLong(byte[] b, Offset offset) {
216	return numberReader.readLong(b, offset);
217	}
218
219	public Long[] readLongArray(byte[] b, int length, Offset offset) {
220	return numberReader.readLongArray(b, length, offset);
221	}
222
223	public double readTimestamp(byte[] b, Offset offset) {
224	return numberReader.readTimestamp(b, offset);
225	}
226
227	public void setCpuFrequency(long frequency) {
228	numberReader.setCpuFrequency(frequency);
229	}
230
231	public void setEncoding(String encoding) {
232	stringReader.setEncoding(encoding);
233	}
234	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/util/binary/BFParserFactory.java (+36 lines)
1	package org.eclipse.hyades.loaders.util.binary;
2
3	import java.util.HashMap;
4	import java.util.Map;
5
6	import org.eclipse.hyades.loaders.util.HierarchyContext;
7	import org.eclipse.hyades.loaders.util.binary.v1_0.ParserImpl1_0;
8
9	public class BFParserFactory {
10	private static final Class[] constructorArgs = new Class[] {HierarchyContext.class, BFReader.class};
11
12	private final Map parsers = new HashMap();
13
14	public BFParserFactory() {
15	ParserImpl1_0.register(this);
16	}
17
18	public BFParser get(BFHeader header, HierarchyContext context, BFReader reader) {
19	Class parserClass = (Class) parsers.get(new Double(header.getVersion().getVersion()));
20	if (parserClass == null) {
21	return null;
22	}
23
24	try {
25	return (BFParser) parserClass.getConstructor(constructorArgs).newInstance(new Object[] {context, reader});
26	} catch (Exception ex) {
27	ex.printStackTrace();
28	}
29
30	return null;
31	}
32
33	public void put(Double version, Class parser) {
34	parsers.put(version, parser);
35	}
36	}