Attachment #93129 for bug #209343

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




 **********************************************************************/
package org.eclipse.hyades.loaders.hierarchy;

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


/**
 * @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, Byte.toString(value));
	}

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

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

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

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

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


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

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/**********************************************************************
 * Copyright (c) 2005 - 2008 IBM Corporation, Intel Corporation.
 * All rights reserved. This content is made available under
 * the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html       
 * $Id$
 *
 * Contributors:
 * Stas Polevic - Initial contribution
 **********************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

public class BFThreadInterruptCalledParser extends BFMonNotifyCalledParser {

	public static final Short ID = new Short((short) 1043);
	
	public static final String NAME = "threadInterruptCalled"; 
	
	public BFThreadInterruptCalledParser() {
		super(ID, NAME);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.util;

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

import org.eclipse.hyades.loaders.internal.binary.BFHeader;
import org.eclipse.hyades.loaders.internal.binary.BFParser;
import org.eclipse.hyades.loaders.internal.binary.BFParserFactory;
import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.Offset;
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;
import org.eclipse.hyades.models.util.ModelDebugger;

public class BinaryLoader extends XMLLoader {

	private final BFParserFactory parserFactory = new BFParserFactory();
	
	private final BFHeader formatHeader = new BFHeader();
	
	private final BFReader reader = new BFReader();
	
	private boolean loadXml = true; 

	public BinaryLoader(TRCAgent agent) {
		super(agent);
	}

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

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

	public boolean isLoadXml() {
		return loadXml;
	}

	public void setLoadXml(boolean loadXml) {
		this.loadXml = loadXml;
	}

	public void loadEvent(byte[] buffer, int offset, int length, boolean loadToModel) throws InvalidXMLException {
		if (isLoadXml()) {
			super.loadEvent(buffer, offset, length, loadToModel);
			return;
		}
		
		setLoadToModel(loadToModel);
		if (ModelDebugger.INSTANCE.debugEventsToFile) {
			writeToBinaryOutputFile(buffer, offset, length);
		} else {
			Offset marker = new Offset(offset, length);
			if (formatHeader.parse(buffer, offset, marker)) {
				formatHeader.visit(reader);
			}

			BFParser parser = parserFactory.get(formatHeader, context, reader);
//			if(getContext().getAgent()==null)
//			{
//				LoadersUtils.createAgent(getContext());
//			}
			parser.parseEvents(buffer, marker);
		}
	}

	public void loadEvents(InputStream inputStream, long offset, long length) throws InvalidEventException {
		if (isLoadXml()) {
			super.loadEvents(inputStream, offset, length);
			return;
		}

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

		try {
			if (!formatHeader.parse(inputStream, marker)) {
				return;
			}
			formatHeader.visit(reader);
			
			BFParser parser = parserFactory.get(formatHeader, context, reader);
			
//			if(getContext().getAgent()==null)
//			{
//				LoadersUtils.createAgent(getContext());
//			}
			parser.parseEvents(inputStream, marker);
			if ((getContext().getAgent() != null) && (getContext().getAgent().eResource() != null) && !getContext().getAgent().eResource().isModified()) {
				getContext().getAgent().eResource().setModified(true);
			}
		} catch (Exception e) {
			e.printStackTrace();
			throw new InvalidXMLException(e);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/**********************************************************************
 * Copyright (c) 2005 - 2008 IBM Corporation, Intel Corporation.
 * All rights reserved. This content is made available under
 * the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html       
 * $Id$
 *
 * Contributors:
 * Stas Polevic - Initial contribution
 **********************************************************************/

package org.eclipse.hyades.loaders.internal.binary.v1;

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

public class BFMonNotifyCalledParser extends BinaryFragmentParser {

	public static final Short ID = new Short((short) 1042);
	
	public static final String NAME = "monNotifyCalled"; 

	public BFMonNotifyCalledParser() {
		super(ID, NAME);
	}
	
	protected BFMonNotifyCalledParser(Short id, String name) {
		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(IS_NOTIFY_ALL, reader.readByte(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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.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);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.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 = Magic.TBF_INDENT;
	
	private Version version = Version.VERSION_1_0;

	private Platform platform = Platform.IA32;
	
	private Endianness endianness = Endianness.BIG_ENDIAN;
	
	public BFHeader() {
	}
	
	public boolean parse(InputStream inputStream, Offset offset) throws IOException {
		byte[] header = new byte[LENGTH];
		if (inputStream.read(header) < 0) {
			throw new IllegalArgumentException("Malformed header");
		}
		return parse(header, 0, offset);
	}
	
	public boolean parse(byte[] header, int start, Offset offset) {
		Offset marker = new Offset(start, LENGTH);

		// indent is ignored
		marker.increaseOffset(1);
		magic = Magic.read(header, marker);
		if (magic == null) {
			return false;
		}
		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);
		return true;
	}

	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));
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

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

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) {
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/**********************************************************************
 * Copyright (c) 2005 - 2008 IBM Corporation, Intel Corporation.
 * All rights reserved. This content is made available under
 * the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html       
 * $Id$
 *
 * Contributors:
 * Stas Polevic - Initial contribution
 **********************************************************************/

package org.eclipse.hyades.loaders.internal.binary.v1;

public class BFThreadStartCalledParser extends BFMonNotifyCalledParser {
	public static final Short ID = new Short((short) 1044);
	
	public static final String NAME = "threadStartCalled"; 
	
	public BFThreadStartCalledParser() {
		super(ID, NAME);
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

import org.eclipse.hyades.loaders.util.BinaryFragmentLoader;
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";

    public static final String IS_NOTIFY_ALL = "isNotifyAll";

    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);
    }
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

public class BFFrequencyParser extends BinaryFragmentParser {
	public static final Short ID = new Short((short)2);

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		
		long frequency = reader.readLong(data, offset);
		reader.setCpuFrequency(frequency);
		
		return true;
	}		
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

import java.io.IOException;

public class BinaryFragment {

	public static final int HEADER_LENGTH = 6;

	Short id;
	
	int length;
	
	int bodyOffset;
	
	byte[] body;
	
	public BinaryFragment(byte[] header, int offset, BFReader reader) throws IOException {
		Offset headerMarker = new Offset(offset, offset + 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 int getBodyOffset() {
		return bodyOffset;
	}

	public void setBodyOffset(int bodyOffset) {
		this.bodyOffset = bodyOffset;
	}

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

	public void setBody(byte[] body) {
		this.body = body;
	}
	
	public static boolean isEOF(byte[] header, int offset) {
		int headerOffset = offset + HEADER_LENGTH;

		if (headerOffset > header.length) {
			return true;
		}
		for (int i = offset; i < headerOffset; ++i) {
			if (header[i] != 0) {
				return false;
			}
		}
		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

public class BFEncodingParser extends BinaryFragmentParser {
	public static final Short ID = new Short((short)1);

	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		byte[] data = fragment.getBody();
		
		String encoding = reader.readString(data, offset);
		reader.setEncoding(encoding);
		
		return true;
	}		
	
	

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

public interface StringReader {
	public void setEncoding(String encoding);
	
	public String readString(byte[] b, Offset offset);

	public String[] readStringArray(byte[] b, int length, Offset offset);
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

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

import org.eclipse.hyades.loaders.internal.binary.v1.ParserImpl1;
import org.eclipse.hyades.loaders.util.HierarchyContext;

public class BFParserFactory {
	private static final Class[] constructorArgs = new Class[] {HierarchyContext.class, BFReader.class};
	
	private final Map parsers = new HashMap();
	
	public BFParserFactory() {
		ParserImpl1.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);
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.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);
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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

public class ParserImpl1 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(HierarchyContext context, BFReader reader) {
		this.context = context;
		this.reader = reader;
		initialize();
	}

	protected void initialize() {
		// System handlers 0-1000
		messageHandlers.put(BFEncodingParser.ID, BFEncodingParser.class);
		messageHandlers.put(BFFrequencyParser.ID, BFFrequencyParser.class);
		
		// 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);
		// Insert Custom message parser here
		messageHandlers.put(BFMonNotifyCalledParser.ID, BFMonNotifyCalledParser.class);
		messageHandlers.put(BFThreadInterruptCalledParser.ID, BFThreadInterruptCalledParser.class);
		messageHandlers.put(BFThreadStartCalledParser.ID, BFThreadStartCalledParser.class);
	}
	
	public void parseEvents(byte[] buffer, Offset marker) {
		try {
			do {
				BinaryFragment binaryFragment = getBinaryFragment(buffer, marker);
				if (binaryFragment == null) {
					break;
				} else if (binaryFragment.getId() == null) {
					continue;
				}
				parseBinaryFragment(binaryFragment, marker);
			} while (true);
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

	public void parseEvents(InputStream inputStream, Offset marker) {
		try {
			do {
				BinaryFragment binaryFragment = getBinaryFragment(inputStream, marker);
				if (binaryFragment == null) {
					break;
				} else if (binaryFragment.getId() == null) {
					continue;
				}
				parseBinaryFragment(binaryFragment, marker);
			} while (true);
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

	protected BinaryFragment getBinaryFragment(byte[] buffer, Offset marker) throws IOException {
		if (BinaryFragment.isEOF(buffer, marker.getOffset())) {
			return null;
		}
		BinaryFragment binaryFragment = new BinaryFragment(buffer, marker.getOffset(), reader);
		if (marker.increaseOffset(BinaryFragment.HEADER_LENGTH) < 0) {
			return null;
		}
		
		binaryFragment.setBody(buffer);
		binaryFragment.setBodyOffset(marker.getOffset());
		if (marker.increaseOffset(binaryFragment.getLength()) < 0) {
			return null;
		}
		
		if (binaryFragment.getId() == null) {
			System.err.println("Unparseable event " + buffer);
		}

		return binaryFragment;
	}
	
	protected BinaryFragment getBinaryFragment(InputStream inputStream, Offset marker) throws IOException {
		byte[] header = new byte[BinaryFragment.HEADER_LENGTH];
		if (inputStream.read(header) < 0) {
			return null;
		}
		if (BinaryFragment.isEOF(header, 0)) {
			return null;
		}
		BinaryFragment binaryFragment = new BinaryFragment(header, 0, reader);
		if (marker.increaseOffset(BinaryFragment.HEADER_LENGTH) < 0) {
			return null;
		}

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

		binaryFragment.setBody(body);
		if (marker.increaseOffset(binaryFragment.getLength()) < 0) {
			return null;
		}
		
		if (binaryFragment.getId() == null) {
			System.err.println("Unparseable event " + header);
		}

		return binaryFragment;
	}
	
	protected void parseBinaryFragment(BinaryFragment binaryFragment, Offset marker) 
			throws InstantiationException, IllegalAccessException {
		BinaryFragmentParser fragmentParser = getFragmentParser(binaryFragment.getId());
		
		if (fragmentParser.getClass().equals(IgnoredBinaryFragmentParser.class)) {
			System.err.println("Got unknown message at " + marker.getOffset());
		}

		fragmentParser.initialize(context);
		Offset bodyOffset = new Offset(binaryFragment.getBodyOffset(), binaryFragment.getBodyOffset() + binaryFragment.getLength());
		if (fragmentParser.parse(binaryFragment, bodyOffset, reader)) {
			fragmentParser.addYourselfInContext();
			if ((context.getAgent() != null) && (context.getAgent().eResource() != null) && !context.getAgent().eResource().isModified()) {
				context.getAgent().eResource().setModified(true);
			}
		}
	}

	protected BinaryFragmentParser getFragmentParser(Short id) throws InstantiationException, IllegalAccessException {
		Class clazz = (Class) messageHandlers.get(id);

		if (clazz == null) {
			return new IgnoredBinaryFragmentParser();
		}
		BinaryFragmentParser fragmentParser = (BinaryFragmentParser) clazz.newInstance();
		if (fragmentParser == null) {
			return new IgnoredBinaryFragmentParser();
		}
		
		return fragmentParser; 
	}

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

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}

}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.util;

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);
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}


}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

public class IgnoredBinaryFragmentParser extends BinaryFragmentParser {
	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
		System.out.println("Ignored handler was invoked for id [" + fragment.getId() + "]");
		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary;

import java.io.InputStream;

public interface BFParser {
	public void parseEvents(InputStream inputStream, Offset marker);

	public void parseEvents(byte[] buffer, Offset marker);
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

import org.eclipse.hyades.loaders.internal.binary.BFReader;
import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
import org.eclipse.hyades.loaders.internal.binary.IgnoredBinaryFragmentParser;
import org.eclipse.hyades.loaders.internal.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;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Intel Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Stanislav Polevic, Intel - Initial API and Implementation 
 * 	  
 * $Id: 
 *******************************************************************************/
package org.eclipse.hyades.loaders.internal.binary.v1;

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

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;
	}
}

Return to bug 209343

Lines 11-16 Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/hierarchy/IgnoredXMLFragmentLoader.java (-2 / +28 lines)
11	**********************************************************************/	11	**********************************************************************/
12	package org.eclipse.hyades.loaders.hierarchy;	12	package org.eclipse.hyades.loaders.hierarchy;
13		13
		14	import org.eclipse.hyades.loaders.util.BinaryFragmentLoader;
14	import org.eclipse.hyades.loaders.util.HierarchyContext;	15	import org.eclipse.hyades.loaders.util.HierarchyContext;
15	import org.eclipse.hyades.loaders.util.XMLFragmentLoader;	16	import org.eclipse.hyades.loaders.util.XMLFragmentLoader;
16		17
Lines 18-24 Link Here
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, Byte.toString(value));
		39	}
		40
		41	public void addAttribute(String name, short value) {
		42	addAttribute(name, Short.toString(value));
		43	}
		44
		45	public void addAttribute(String name, int value) {
		46	addAttribute(name, Integer.toString(value));
		47	}
		48
		49	public void addAttribute(String name, long value) {
		50	addAttribute(name, Long.toString(value));
		51	}
		52
		53	public void addAttribute(String name, double value) {
		54	addAttribute(name, Double.toString(value));
		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/internal/binary/v1/BFNodeParser.java (+43 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Intel Corporation.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Stanislav Polevic, Intel - Initial API and Implementation
10	*
11	* $Id:
12	*******************************************************************************/
13	package org.eclipse.hyades.loaders.internal.binary.v1;
14
15	import org.eclipse.hyades.loaders.internal.binary.BFReader;
16	import org.eclipse.hyades.loaders.internal.binary.BinaryFragment;
17	import org.eclipse.hyades.loaders.internal.binary.BinaryFragmentParser;
18	import org.eclipse.hyades.loaders.internal.binary.Offset;
19	import org.eclipse.hyades.loaders.util.BinaryFragmentLoader;
20
21	public class BFNodeParser extends BinaryFragmentParser {
22
23	public static final Short ID = new Short((short)1001);
24
25	public static final String NAME = "node";
26
27	public BFNodeParser() {
28	super(ID, NAME);
29	}
30
31	public boolean parse(BinaryFragment fragment, Offset offset, BFReader reader) {
32	byte[] data = fragment.getBody();
33	BinaryFragmentLoader loader = getLoader();
34
35	loader.addAttribute(NODE_ID, reader.readString(data, offset));
36	loader.addAttribute(HOSTNAME, reader.readString(data, offset));
37	loader.addAttribute(IPADDRESS, reader.readString(data, offset));
38	loader.addAttribute(TIMEZONE, reader.readTimestamp(data, offset));
39	loader.addAttribute(TIMESTAMP, reader.readLong(data, offset));
40
41	return true;
42	}
43	}

Added Link Here

(-)src-hierarchy/org/eclipse/hyades/loaders/internal/binary/v1/BFThreadInterruptCalledParser.java (+23 lines)
1	/**********************************************************************
2	* Copyright (c) 2005 - 2008 IBM Corporation, Intel Corporation.
3	* All rights reserved. This content is made available under
4	* the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id$
8	*
9	* Contributors:
10	* Stas Polevic - Initial contribution
11	**********************************************************************/
12	package org.eclipse.hyades.loaders.internal.binary.v1;
13
14	public class BFThreadInterruptCalledParser extends BFMonNotifyCalledParser {
15
16	public static final Short ID = new Short((short) 1043);
17
18	public static final String NAME = "threadInterruptCalled";
19
20	public BFThreadInterruptCalledParser() {
21	super(ID, NAME);
22	}
23	}