jevio-base/src/main/java/org/jlab/coda/jevio

diff -N BankHeader.java
--- BankHeader.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,106 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-/**
- * This the header for an evio bank structure (<code>EvioBank</code>). It does not contain the raw data, just the
- * header. Note: since an "event" is really just the outermost bank, this is also the header for an
- * <code>EvioEvent</code>.
- * 
- * @author heddle
- * 
- */
-public final class BankHeader extends BaseStructureHeader {
-	
-	/**
-	 * Null constructor.
-	 */
-	public BankHeader() {
-	}
-
-	/**
-	 * Constructor
-	 * @param tag the tag for the bank header.
-	 * @param dataType the data type for the content of the bank.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public BankHeader(int tag, DataType dataType, int num) {
-		super(tag, dataType, num);
-	}
-
-	/**
-	 * Constructor
-	 * @param tag the tag for the bank header.
-	 * @param dataType the (int) data type for the content of the bank.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public BankHeader(int tag, int dataType, int num) {
-		super(tag, dataType, num);
-	}
-
-    /**
-     * {@inheritDoc}
-     */
-    public int getHeaderLength() {return 2;}
-
-    /**
-     * {@inheritDoc}
-     */
-    protected void toArray(byte[] bArray, int offset, ByteOrder order) {
-        if (order == ByteOrder.BIG_ENDIAN) {
-            ByteDataTransformer.intToBytes(length, bArray, offset);
-            ByteDataTransformer.shortToBytes(shortValue(tag), bArray, offset+4);
-            bArray[offset+6] = byteValue(dataType);
-            bArray[offset+7] = byteValue(number);
-        }
-        else {
-            ByteDataTransformer.intToBytes(Integer.reverseBytes(length), bArray, offset);
-            bArray[offset+4] = byteValue(number);
-            bArray[offset+5] = byteValue(dataType);
-            ByteDataTransformer.shortToBytes(Short.reverseBytes(shortValue(tag)), bArray, offset+6);
-        }
-        
-    }
-
-
-	/**
-	 * Obtain a string representation of the bank header.
-	 * 
-	 * @return a string representation of the bank header.
-	 */
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(512);
-		sb.append(String.format("bank length: %d\n", length));
-		sb.append(String.format("number:      %d\n", number));
-		sb.append(String.format("data type:   %s\n", getDataTypeName()));
-		sb.append(String.format("tag:         %d\n", tag));
-		return sb.toString();
-	}
-	
-	/**
-	 * Write myself out a byte buffer. This write is relative--i.e., it uses the current position of the buffer.
-	 * 
-	 * @param byteBuffer the byteBuffer to write to.
-	 * @return the number of bytes written, which for a BankHeader is 8.
-	 */
-	@Override
-	public int write(ByteBuffer byteBuffer) {
-		byteBuffer.putInt(length);
-        
-        if (byteBuffer.order() == ByteOrder.BIG_ENDIAN) {
-            byteBuffer.putShort(shortValue(tag));
-            byteBuffer.put(byteValue(dataType));
-            byteBuffer.put(byteValue(number));
-        }
-        else {
-            byteBuffer.put(byteValue(number));
-            byteBuffer.put(byteValue(dataType));
-            byteBuffer.putShort(shortValue(tag));
-        }
-
-		return 8;
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N BaseStructure.java
--- BaseStructure.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,1567 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.util.Arrays;
-import java.util.Enumeration;
-import java.util.Vector;
-import java.util.LinkedList;
-import java.io.UnsupportedEncodingException;
-import java.io.StringWriter;
-
-import javax.swing.tree.DefaultMutableTreeNode;
-import javax.swing.tree.MutableTreeNode;
-import javax.swing.tree.TreeNode;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-import javax.xml.stream.XMLOutputFactory;
-
-/**
- * This is the base class for all evio structures: Banks, Segments, and TagSegments. It implements
- * <code>MutableTreeNode</code> because a tree representation of events is created when a new event is parsed.
- * 
- * @author heddle
- * @author timmer - add byte order tracking
- *
- */
-public abstract class BaseStructure implements IEvioStructure, MutableTreeNode, IEvioWriter {
-
-	/**
-	 * Holds the header of the bank.
-	 */
-	protected BaseStructureHeader header;
-
-	/**
-	 * The raw data of the structure.
-	 */
-	protected byte rawBytes[];
-
-	/**
-	 * Used if raw data should be interpreted as ints.
-	 */
-	protected int intData[];
-
-	/**
-	 * Used if raw data should be interpreted as longs.
-	 */
-	protected long longData[];
-
-	/**
-	 * Used if raw data should be interpreted as shorts.
-	 */
-	protected short shortData[];
-
-	/**
-	 * Used if raw data should be interpreted as doubles.
-	 */
-	protected double doubleData[];
-
-    /**
-     * Used if raw data should be interpreted as doubles.
-     */
-    protected float floatData[];
-
-    /**
-     * Used if raw data should be interpreted as a string.
-     */
-    protected StringBuffer stringData;
-
-    /**
-     * Keep track of end of the last string added to stringData (including null but not padding).
-     */
-    private int stringEnd;
-
-    /**
-     * The number of stored data items like number of banks, ints, floats, etc.
-     * (not the size in ints or bytes). Some items may be padded such as shorts
-     * and bytes. This will tell the meaningful number of such data items.
-     * In the case of containers, returns number of bytes not in header.
-     */
-    protected int numberDataItems;
-
-    /**
-     * Give the XML output proper indentation.
-     */
-    protected String xmlIndent = "";
-
-    /**
-     * Name of this object as an XML element.
-     */
-    protected String xmlElementName;
-
-    /**
-     * Name of this object's contents as an XML attribute if it is a structure type.
-     */
-    protected String xmlContentAttributeName;
-
-    /**
-     * Endianness of the data if appropriate,
-     * either {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-     */
-    protected ByteOrder byteOrder;
-
-	/**
-	 * The parent of the structure. If it is an "event", the parent is null. This is used for creating trees for a
-	 * variety of purposes (not necessarily graphical.)
-	 */
-	private BaseStructure parent;
-
-	/**
-	 * Holds the children of this structure. This is used for creating trees for a variety of purposes
-     * (not necessarily graphical.)
-	 */
-	protected Vector<BaseStructure> children;
-
-    /**
-	 * Constructor using a provided header
-	 * 
-	 * @param header the header to use.
-	 * @see BaseStructureHeader
-	 */
-	public BaseStructure(BaseStructureHeader header) {
-		this.header = header;
-        // by default we're big endian since this is java
-        byteOrder = ByteOrder.BIG_ENDIAN;
-        setXmlNames();
-	}
-
-	/**
-	 * A convenience method use instead of "instanceof" to see what type of structure we have. Note: this returns the
-	 * type of this structure, not the type of data (the content type) this structure holds.
-	 * 
-	 * @return the <code>StructureType</code> of this structure.
-	 * @see StructureType
-	 */
-	@Override
-	public abstract StructureType getStructureType();
-
-    /**
-     * This is a method that must be filled in by subclasses. Write this structure out as an XML record.
-     *
-     * @param xmlWriter the writer used to write the events. It is tied to an open file.
-     */
-    public abstract void toXML(XMLStreamWriter xmlWriter);
-
-	/**
-	 * Get the element name for the structure for writing to XML.
-	 * 
-	 * @return the element name for the structure for writing to XML.
-	 */
-	public abstract String getXMLElementName();
-
-    /**
-     * Write this structure out as an XML format string.
-     */
-    public String toXML() {
-
-        try {
-            StringWriter sWriter = new StringWriter();
-            XMLStreamWriter xmlWriter = XMLOutputFactory.newInstance().createXMLStreamWriter(sWriter);
-
-            toXML(xmlWriter);
-            return sWriter.toString();
-        }
-        catch (XMLStreamException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-
-    /**
-     * Set the name of this object's XML element and also content type attribute if content is structure type.
-     */
-    protected void setXmlNames() {
-
-        // is this structure holding a structure type container?
-        boolean holdingStructureType = false;
-
-        // type of data held by this container type
-        DataType type = header.getDataTypeEnum();
-
-        switch (type) {
-            case CHAR8:
-                xmlElementName = "int8"; break;
-            case UCHAR8:
-                xmlElementName = "uint8"; break;
-            case SHORT16:
-                xmlElementName = "int16"; break;
-            case USHORT16:
-                xmlElementName = "uint16"; break;
-            case INT32:
-                xmlElementName = "int32"; break;
-            case UINT32:
-                xmlElementName = "uint32"; break;
-            case LONG64:
-                xmlElementName = "int64"; break;
-            case ULONG64:
-                xmlElementName = "uint64"; break;
-            case FLOAT32:
-                xmlElementName = "float32"; break;
-            case DOUBLE64:
-                xmlElementName = "float64"; break;
-            case CHARSTAR8:
-                xmlElementName = "string"; break;
-
-            case UNKNOWN32:
-                holdingStructureType = true;
-                xmlContentAttributeName = "unknown32";
-                break;
-
-            case TAGSEGMENT:
-            case ALSOTAGSEGMENT:
-                holdingStructureType = true;
-                xmlContentAttributeName = "tagsegment";
-                break;
-
-            case SEGMENT:
-            case ALSOSEGMENT:
-                holdingStructureType = true;
-                xmlContentAttributeName = "segment";
-                break;
-
-            case BANK:
-            case ALSOBANK:
-                holdingStructureType = true;
-                xmlContentAttributeName = "bank";
-                break;
-
-            default:
-                xmlElementName = "unknown"; break;
-        }
-
-        if (holdingStructureType) {
-            // Which container type are we (NOT what are we holding)?
-            // Because that determines our element name.
-            StructureType structType = getStructureType();
-            if (structType == StructureType.UNKNOWN32) {
-                xmlElementName = "unknown32";
-            }
-            else {
-                xmlElementName = getXMLElementName();
-            }
-        }
-
-    }
-
-    /**
-     * Set the indentation (string of spaces) for more pleasing XML output.
-     * @param s the indentation (string of spaces) for more pleasing XML output
-     */
-    protected void setXmlIndent(String s) {
-        xmlIndent = s;
-    }
-
-    /**
-     * Increase the indentation (string of spaces) of the XML output.
-     */
-    protected void increaseXmlIndent() {
-        xmlIndent += "   ";
-    }
-
-    /**
-     * Decrease the indentation (string of spaces) of the XML output.
-     */
-    protected void decreaseXmlIndent() {
-        xmlIndent = xmlIndent.substring(0, xmlIndent.length() - 3);
-    }
-
-    /**
-     * What is the byte order of this data?
-     * @return {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}
-     */
-    public ByteOrder getByteOrder() {
-        return byteOrder;
-    }
-
-    /**
-     * Set the byte order of this data. This method <b>cannot</b> be used to swap data.
-     * It is only used to describe the endianness of the rawdata contained.
-     * @param byteOrder {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}
-     */
-    public void setByteOrder(ByteOrder byteOrder) {
-        this.byteOrder = byteOrder;
-    }
-
-	/**
-	 * Is a byte swap required? This is java and therefore big endian. If data is
-     * little endian, then a swap is required.
-	 * 
-	 * @return <code>true</code> if byte swapping is required (data is little endian).
-	 */
-	public boolean isSwap() {
-		return byteOrder == ByteOrder.LITTLE_ENDIAN;
-	}
-
-	/**
-	 * Get the description from the name provider (dictionary), if there is one.
-	 * 
-	 * @return the description from the name provider (dictionary), if there is one. If not, return
-	 *         NameProvider.NO_NAME_STRING.
-	 */
-	@Override
-	public String getDescription() {
-		return NameProvider.getName(this);
-	}
-
-	/**
-	 * Obtain a string representation of the structure.
-	 * 
-	 * @return a string representation of the structure.
-	 */
-	@Override
-	public String toString() {
-		StructureType stype = getStructureType();
-		DataType dtype = header.getDataTypeEnum();
-
-		String description = getDescription();
-		if (NameProvider.NO_NAME_STRING.equals(description)) {
-			description = null;
-		}
-		String s = stype + " of " + dtype + "s " + " len (ints): " + header.length + " " + " tag: " + header.tag;
-		if (this instanceof EvioBank) {
-			s += " num: " + header.number;
-		}
-
-		if (rawBytes == null) {
-			s += " data: null";
-		}
-		else {
-			s += " datalen (bytes): " + rawBytes.length;
-		}
-
-		if (description != null) {
-			s += " [" + description + "]";
-		}
-
-		int numChildren = (children == null) ? 0 : children.size();
-
-		s += " <#children: " + numChildren + ">";
-		return s;
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Return the header for this structure.
-	 * 
-	 * @return the header for this structure.
-	 */
-	@Override
-	public BaseStructureHeader getHeader() {
-		return header;
-	}
-
-    /**
-     * Get the number of stored data items like number of banks, ints, floats, etc.
-     * (not the size in ints or bytes). Some items may be padded such as shorts
-     * and bytes. This will tell the meaningful number of such data items.
-     * In the case of containers, returns number of bytes not in header.
-     *
-     * @return number of stored data items (not size or length),
-     *         or number of bytes if container
-     */
-    public int getNumberDataItems() {
-        if (isContainer()) {
-            numberDataItems = header.getLength() + 1 - header.getHeaderLength();
-        }
-
-        // if the calculation has not already been done ...
-        if (numberDataItems < 1) {
-            // When parsing a file or byte array, it is not fully unpacked until data
-            // is asked for specifically, for example as an int array or a float array.
-            // Thus we don't know how many of a certain item (say doubles) there is.
-            // But we can figure that out now based on the size of the raw data byte array.
-            int divisor = 0;
-            DataType type = header.getDataTypeEnum();
-
-            switch (type) {
-                case CHAR8:
-                case UCHAR8:
-                    divisor = 1; break;
-                case SHORT16:
-                case USHORT16:
-                    divisor = 2; break;
-                case INT32:
-                case UINT32:
-                case FLOAT32:
-                    divisor = 4; break;
-                case LONG64:
-                case ULONG64:
-                case DOUBLE64:
-                    divisor = 8; break;
-                case CHARSTAR8:
-                    String[] s = getStringData();
-                    numberDataItems = s.length;
-                    break;
-                default:
-            }
-
-            if (divisor > 0) numberDataItems = rawBytes.length/divisor;
-        }
-
-        return numberDataItems;
-    }
-
-    /**
-     * Get the length of this structure in bytes, including the header.
-     * @return the length of this structure in bytes, including the header.
-     */
-    public int getTotalBytes() {
-        return 4*(header.getLength() + 1);
-    }
-
-	/**
-	 * Get the raw data of the structure.
-	 * 
-	 * @return the raw data of the structure.
-	 */
-	public byte[] getRawBytes() {
-		return rawBytes;
-	}
-
-	/**
-	 * Set the data for the structure.
-	 * 
-	 * @param rawBytes the structure raw data.
-	 */
-	public void setRawBytes(byte[] rawBytes) {
-		this.rawBytes = rawBytes;
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Gets the raw data as an integer array,
-     * if the content type as indicated by the header is appropriate.
-     * NOTE: since Java does not have unsigned primitives, both INT32 and UINT32
-	 * data types will be returned as int arrays. The application will have to deal
-     * with reinterpreting signed ints that are negative as unsigned ints.
-	 * 
-	 * @return the data as an int array, or <code>null</code> if this makes no sense for the given content type.
-	 */
-	@Override
-	public int[] getIntData() {
-
-		switch (header.getDataTypeEnum()) {
-		case INT32:
-		case UINT32:
-			if (intData == null) {
-				if (rawBytes == null) {
-					return null;
-				}
-				intData = ByteDataTransformer.getAsIntArray(rawBytes, byteOrder);
-			}
-			return intData;
-		default:
-			return null;
-		}
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Gets the raw data as a long array,
-     * if the content type as indicated by the header is appropriate.
-     * NOTE: since Java does not have unsigned primitives, both LONG64 and ULONG64
-     * data types will be returned as long arrays. The application will have to deal
-     * with reinterpreting signed longs that are negative as unsigned longs.
-	 * 
-	 * @return the data as an long array, or <code>null</code> if this makes no sense for the given content type.
-	 */
-	@Override
-	public long[] getLongData() {
-
-		switch (header.getDataTypeEnum()) {
-		case LONG64:
-		case ULONG64:
-			if (longData == null) {
-				if (rawBytes == null) {
-					return null;
-				}
-				longData = ByteDataTransformer.getAsLongArray(rawBytes, byteOrder);
-			}
-			return longData;
-		default:
-			return null;
-		}
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Gets the raw data as a float array,
-     * if the content type as indicated by the header is appropriate.
-	 * 
-	 * @return the data as an double array, or <code>null</code> if this makes no sense for the given contents type.
-	 */
-	@Override
-	public float[] getFloatData() {
-
-		switch (header.getDataTypeEnum()) {
-		case FLOAT32:
-			if (floatData == null) {
-				if (rawBytes == null) {
-					return null;
-				}
-				floatData = ByteDataTransformer.getAsFloatArray(rawBytes, byteOrder);
-			}
-			return floatData;
-		default:
-			return null;
-		}
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Gets the raw data as a double array,
-     * if the content type as indicated by the header is appropriate.
-	 * 
-	 * @return the data as an double array, or <code>null</code> if this makes no sense for the given content type.
-	 */
-	@Override
-	public double[] getDoubleData() {
-
-		switch (header.getDataTypeEnum()) {
-		case DOUBLE64:
-			if (doubleData == null) {
-				if (rawBytes == null) {
-					return null;
-				}
-				doubleData = ByteDataTransformer.getAsDoubleArray(rawBytes, byteOrder);
-			}
-			return doubleData;
-		default:
-			return null;
-		}
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Gets the raw data as a double array,
-     * if the contents type as indicated by the header is appropriate.
-     * NOTE: since Java does not have unsigned primitives, both SHORT16 and USHORT16
-     * data types will be returned as short arrays. The application will have to deal
-     * with reinterpreting signed shorts that are negative as unsigned longs.
-	 * 
-	 * @return the data as an short array, or <code>null</code> if this makes no sense for the given contents type.
-	 */
-	@Override
-	public short[] getShortData() {
-
-		switch (header.getDataTypeEnum()) {
-		case SHORT16:
-		case USHORT16:
-			if (shortData == null) {
-				if (rawBytes == null) {
-					return null;
-				}
-				shortData = ByteDataTransformer.getAsShortArray(rawBytes, byteOrder);
-			}
-			return shortData;
-		default:
-			return null;
-		}
-	}
-
-	/**
-	 * This is a method from the IEvioStructure Interface. Gets the raw data as an byte array,
-     * if the contents type as indicated by the header is appropriate.
-     * NOTE: since Java does not have unsigned primitives, CHARSTAR8, CHAR8 and UCHAR8
-	 * data types will be returned as byte arrays. The application will have to deal
-     * with reinterpreting bytes as characters, if necessary.
-	 * 
-	 * @return the data as an byte array, or <code>null</code> if this makes no sense for the given contents type.
-	 */
-	@Override
-	public byte[] getByteData() {
-
-		switch (header.getDataTypeEnum()) {
-		case CHARSTAR8:
-		case CHAR8:
-		case UCHAR8:
-			return rawBytes;
-		default:
-			return null;
-		}
-	}
-
-    /**
-     * This is a method from the IEvioStructure Interface. Gets the raw data (ascii) as an
-     * array of String objects, if the contents type as indicated by the header is appropriate.
-     * For any other behavior, the user should retrieve the data as a byte array and
-     * manipulate it in the exact manner desired.<p>
-     * Originally, in evio versions 2 and 3, only one string was stored. Recent changes cause
-     * an array of strings to be stored and retrieved. The changes are backwards compatible.
-     *
-     * The following is true about the string raw data format:
-     * <ul>
-     * <li>All strings are immediately followed by an ending null (0).
-     * <li>All string arrays are further padded/ended with at least one 0x4 valued ASCII
-     *     char (up to 4 possible).
-     * <li>The presence of 1 to 4 ending 4's distinguishes the recent string array version from
-     *     the original, single string version.
-     * <li>The priginal version string may be padded with anything after its ending null.
-     * <li>Ending non-printing ascii chars (value < 32, = 127) are not included in the string
-     *     since they are there for padding.
-     * </ul>
-     *
-     * @return the data as an array of String objects if DataType is CHARSTAR8, or <code>null</code>
-     *         if this makes no sense for the given type.
-     *
-     */
-    @Override
-    public String[] getStringData() {
-
-        String[] strs;
-        switch (header.getDataTypeEnum()) {
-        case CHARSTAR8:
-            if (stringData == null) {
-                if (rawBytes == null) {
-                    return null;
-                }
-                try {
-                    // stringData contains all elements of rawBytes
-                    stringData = new StringBuffer(new String(rawBytes, "US-ASCII"));
-                }
-                catch (UnsupportedEncodingException e) { /* will never happen */ }
-            }
-
-            // Strings are separated by ASCII nulls (char val = 0) and the end is padded by ASCII 4's
-            // (char val = 4). However, in the legacy versions of evio, there is
-            // only 1 null-terminated string and anything as padding. To accomodate legacy evio, if
-            // there is not an ending ASCII value 4, anything past the first null is ignored.
-            // After doing so, split at the nulls. Do not use the String
-            // method "split" as any empty trailing strings are unfortunately discarded.
-
-            boolean newVersion = true;
-            if (stringData.charAt(stringData.length() - 1) != '\004') {
-                newVersion = false;
-            }
-
-            char c;
-            LinkedList<Integer> nullIndexList = new LinkedList<Integer>();
-
-            for (int i=0; i < stringData.length(); i++) {
-                c = stringData.charAt(i);
-                if ( c == '\000' ) {
-                    nullIndexList.add(i);
-                    // only 1 null terminated string originally in evio v2,3
-                    if (!newVersion) {
-                        break;
-                    }
-                }
-                // Look for any non-printing/control characters (not including null)
-                // and end the string there. Allow new lines (c = 10).
-                else if ( (c < 32 || c == 127) && c != 10 ) {
-                    break;
-                }
-            }
-
-            strs = new String[nullIndexList.size()];
-            int lastIndex, firstIndex=0;
-            for (int i=0; i < nullIndexList.size(); i++) {
-                lastIndex  = nullIndexList.get(i);
-                strs[i]    = stringData.substring(firstIndex, lastIndex);
-                firstIndex = lastIndex + 1;
-            }
-
-            return strs;
-
-        default:
-            return null;
-        }
-    }
-
-    /**
-     * This is a method from the IEvioStructure Interface. Gets the raw data (ascii) as a String,
-     * if the contents type as indicated by the header is appropriate.
-     * NOTE: ending non-printing ascii chars (value < 32) are not included in the string
-     * (since they are most likely there for padding).
-     * For any other behavior, the user should retrieve the data as a byte array and
-     * manipulate it in the exact manner desired.
-     *
-     * @return the data as a String if DataType is CHARSTAR8, or <code>null</code>
-     *         if this makes no sense for the given type.
-     *
-     */
-    //@Override
-    private String getStringDataOrig() {
-
-        switch (header.getDataTypeEnum()) {
-        case CHARSTAR8:
-            if (stringData == null) {
-                if (rawBytes == null) {
-                    return null;
-                }
-                try {
-                    // stringData contains all elements of rawBytes
-                    stringData = new StringBuffer(new String(rawBytes, "US-ASCII"));
-                }
-                catch (UnsupportedEncodingException e) { /* will never happen */ }
-            }
-
-            // When fashioning a return string, we assume ascii (one char per byte).
-            // If there are any bytes = 0 (ie null termination) or other nonprinting chars,
-            // Java includes them in the string, but ignores them when printing.
-            // In light of this and the fact that this data type is padded to make an
-            // integral number of 32 byte chunks, the ending nonprinting chars will be
-            // stripped off when forming the return string.
-            String s = null;
-            try {
-                int endingNonPrintingChars = 0;
-                for (int i=rawBytes.length-1; i >= 0; i--) {
-                    if (rawBytes[i] < 32) {
-                        endingNonPrintingChars++;
-                        continue;
-                    }
-                    break;
-                }
-                s = new String(rawBytes, 0, rawBytes.length - endingNonPrintingChars, "US-ASCII");
-            }
-            catch (UnsupportedEncodingException e) { /* will never happen */ }
-
-            return s;
-
-        default:
-            return null;
-        }
-    }
-
-	/**
-	 * Get the parent of this structure. The outer event bank is the only structure with a <code>null</code>
-     * parent (the only orphan). All other structures have non-null parent giving the container in which they
-     * were embedded. Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @return the parent of this structure.
-	 */
-	@Override
-	public BaseStructure getParent() {
-		return parent;
-	}
-
-	/**
-	 * Get an enumeration of all the children of this structure. If none, it returns a constant,
-     * empty Enumeration. Part of the <code>MutableTreeNode</code> interface.
-	 */
-	@Override
-	public Enumeration<?> children() {
-		if (children == null) {
-			return DefaultMutableTreeNode.EMPTY_ENUMERATION;
-		}
-		return children.elements();
-	}
-
-	/**
-	 * Add a child at the given index.
-	 * 
-	 * @param child the child to add.
-	 * @param index the target index. Part of the <code>MutableTreeNode</code> interface.
-	 */
-	@Override
-	public void insert(MutableTreeNode child, int index) {
-		if (children == null) {
-			children = new Vector<BaseStructure>(10);
-		}
-		children.add(index, (BaseStructure) child);
-	}
-
-	/**
-	 * Convenience method to add a child at the end of the child list. In this application
-	 * where are not concerned with the ordering of the children.
-	 * 
-	 * @param child the child to add. It will be added to the end of child list.
-	 */
-	public void insert(MutableTreeNode child) {
-		if (children == null) {
-			children = new Vector<BaseStructure>(10);
-		}
-		//add to end
-		insert(child, children.size());
-	}
-
-	/**
-	 * Removes the child at index from the receiver. Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @param index the target index for removal.
-	 */
-	@Override
-	public void remove(int index) {
-		children.remove(index);
-	}
-
-	/**
-	 * Removes the child. Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @param child the child node being removed.
-	 */
-	@Override
-	public void remove(MutableTreeNode child) {
-		children.remove(child);
-	}
-
-	/**
-	 * Remove this node from its parent. Part of the <code>MutableTreeNode</code> interface.
-	 */
-	@Override
-	public void removeFromParent() {
-		parent.remove(this);
-	}
-
-	/**
-	 * Set the parent for this node. Part of the <code>MutableTreeNode</code> interface.
-	 */
-	@Override
-	public void setParent(MutableTreeNode parent) {
-		this.parent = (BaseStructure) parent;
-	}
-
-	/**
-	 * This method is not relevant for this implementation.
-     * An empty implementation is provided to satisfy the interface.
-	 * Part of the <code>MutableTreeNode</code> interface.
-	 */
-	@Override
-	public void setUserObject(Object arg0) {
-	}
-
-	/**
-	 * Checks whether children are allowed. Structures of structures can have children.
-     * Structures of primitive data can not. Thus is is entirely determined by the content type.
-     * Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @return <code>true</code> if this node does not hold primitive data,
-     *         i.e., if it is a structure of structures (a container).
-	 */
-	@Override
-	public boolean getAllowsChildren() {
-		return header.getDataTypeEnum().isStructure();
-	}
-
-	/**
-	 * Obtain the child at the given index. Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @param index the target index.
-	 * @return the child at the given index.
-     * @throws ArrayIndexOutOfBoundsException if the index is out of range
-     *	       ({@code index < 0 || index >= children.size()})
-	 */
-	@Override
-	public TreeNode getChildAt(int index) {
-		return children.elementAt(index);
-	}
-
-	/**
-	 * Get the count of the number of children. Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @return the number of children.
-	 */
-	@Override
-	public int getChildCount() {
-		if (children == null) {
-			return 0;
-		}
-		return children.size();
-	}
-
-	/**
-	 * Get the index of a node. Part of the <code>MutableTreeNode</code> interface.
-	 * 
-	 * @return the index of the target node.
-	 */
-	@Override
-	public int getIndex(TreeNode node) {
-		return children.indexOf(node);
-	}
-
-	/**
-	 * Checks whether this is a leaf. Leaves are structures with no children.
-     * All structures that contain primitive data are leaf structures.
-	 * Part of the <code>MutableTreeNode</code> interface.<br>
-	 * Note: this means that an empty container, say a Bank of Segments that have no segments, is a leaf.
-	 * 
-	 * @return <code>true</code> if this is a structure with a primitive data type, i.e., it is not a container
-	 *         structure that contains other structures.
-	 */
-	@Override
-	public boolean isLeaf() {
-		return ((children == null) || (children.size() < 1));
-	}
-	
-	/**
-	 * Checks whether this structure is a container, i.e. a structure of structures.
-	 * @return <code>true</code> if this structure is a container. This is the same check as 
-	 * <code>getAllowsChildren()</code>.
-	 */
-	public boolean isContainer() {
-		return header.getDataTypeEnum().isStructure();
-	}
-
-	/**
-	 * This calls the xml write for all of a structure's children.
-     * It is used for a depth-first traversal through the tree
-	 * when writing an event to xml.
-	 * 
-	 * @param xmlWriter the writer used to write the events. It is tied to an open file.
-	 */
-	protected void childrenToXML(XMLStreamWriter xmlWriter) {
-		if (children == null) {
-			return;
-		}
-        
-        increaseXmlIndent();
-
-		for (BaseStructure structure : children) {
-			structure.setXmlIndent(xmlIndent);
-            structure.toXML(xmlWriter);
-		}
-
-        decreaseXmlIndent();
-	}
-
-	/**
-	 * All structures have a common start to their xml writing
-	 * 
-	 * @param xmlWriter the writer used to write the events. It is tied to an open file.
-	 */
-	protected void commonXMLStart(XMLStreamWriter xmlWriter) {
-		try {
-			xmlWriter.writeCharacters("\n");
-            xmlWriter.writeCharacters(xmlIndent);
-			xmlWriter.writeStartElement(xmlElementName);
-		}
-		catch (XMLStreamException e) {
-			e.printStackTrace();
-		}
-	}
-
-	/**
-	 * All structures have a common data write for their xml writing
-	 * 
-	 * @param xmlWriter the writer used to write the events. It is tied to an open file.
-	 */
-	protected void commonXMLDataWrite(XMLStreamWriter xmlWriter) {
-
-		// only leafs write data
-		if (!isLeaf()) {
-			return;
-		}
-
-		try {
-            String s;
-            String indent = String.format("\n%s", xmlIndent);
-
-			BaseStructureHeader header = getHeader();
-			switch (header.getDataTypeEnum()) {
-			case DOUBLE64:
-				double doubledata[] = getDoubleData();
-                for (int i=0; i < doubledata.length; i++) {
-                    if (i%2 == 0) {
-                        xmlWriter.writeCharacters(indent);
-                    }
-                    s = String.format("%24.16e  ", doubledata[i]);
-                    xmlWriter.writeCharacters(s);
-                }
-				break;
-
-			case FLOAT32:
-				float floatdata[] = getFloatData();
-                for (int i=0; i < floatdata.length; i++) {
-                    if (i%2 == 0) {
-                        xmlWriter.writeCharacters(indent);
-                    }
-                    s = String.format("%14.7e  ", floatdata[i]);
-                    xmlWriter.writeCharacters(s);
-                }
-				break;
-
-			case LONG64:
-			case ULONG64:
-				long longdata[] = getLongData();
-                for (int i=0; i < longdata.length; i++) {
-                    if (i%2 == 0) {
-                        xmlWriter.writeCharacters(indent);
-                    }
-                    s = String.format("%20d  ", longdata[i]);
-                    xmlWriter.writeCharacters(s);
-                }
-				break;
-
-			case INT32:
-			case UINT32:
-				int intdata[] = getIntData();
-                for (int i=0; i < intdata.length; i++) {
-                    if (i%5 == 0) {
-                        xmlWriter.writeCharacters(indent);
-                    }
-                    s = String.format("%11d  ", intdata[i]);
-                    xmlWriter.writeCharacters(s);
-                }
-				break;
-
-			case SHORT16:
-			case USHORT16:
-				short shortdata[] = getShortData();
-                for (int i=0; i < shortdata.length; i++) {
-                    if (i%5 == 0) {
-                        xmlWriter.writeCharacters(indent);

[truncated at 1000 lines; 571 more skipped]

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N BaseStructureHeader.java
--- BaseStructureHeader.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,230 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteOrder;
-
-/**
- * This the  header for the base structure (<code>BaseStructure</code>). It does not contain the raw data, just the
- * header. The three headers for the actual structures found in evio (BANK, SEGMENT, and TAGSEMENT) all extend this.
- * 
- * @author heddle
- * 
- */
-public abstract class BaseStructureHeader implements IEvioWriter {
-
-    /**
-     * The length of the structure in ints. This never includes the first header word itself (which contains the
-     * length).
-     */
-    protected int length;
-
-	/**
-	 * The structure tag.
-	 */
-	protected int tag = 0;
-
-	/**
-	 * The numeric data type of the structure.
-	 */
-	protected int dataType = 0;
-
-	/**
-	 * The number. Only Banks have a number field in their header, so this is only relevant for Banks.
-	 */
-	protected int number;
-
-    /**
-	 * Null constructor.
-	 */
-	public BaseStructureHeader() {
-	}
-	
-	/**
-	 * Constructor
-	 * @param tag the tag for the header.
-	 * @param dataType the enum data type for the content of the structure.
-	 */
-	public BaseStructureHeader(int tag, DataType dataType) {
-		this(tag, dataType.getValue(), 0);
-	}
-
-	/**
-	 * Constructor
-	 * @param tag the tag for the header.
-	 * @param dataType the (int) data type for the content of the structure.
-	 */
-	public BaseStructureHeader(int tag, int dataType) {
-		this(tag, dataType, 0);
-	}
-	
-	/**
-	 * Constructor
-	 * @param tag the tag for the header.
-	 * @param dataType the data type for the content of the structure.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public BaseStructureHeader(int tag, DataType dataType, int num) {
-		this(tag, dataType.getValue(), num);
-	}
-
-	/**
-	 * Constructor
-	 * @param tag the tag for the event header.
-	 * @param dataType the (int) data type for the content of the structure.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public BaseStructureHeader(int tag, int dataType, int num) {
-		this.tag = tag;
-		this.dataType = dataType;
-		this.number = num;
-	}
-
-	
-	/**
-	 * Get the number. Only Banks have a number field in their header, so this is only relevant for Banks.
-	 * 
-	 * @return the number.
-	 */
-	public int getNumber() {
-		return number;
-	}
-
-	/**
-	 * Set the number. Only Banks have a number field in their header, so this is only relevant for Banks.
-	 * 
-	 * @param number the number.
-	 */
-	public void setNumber(int number) {
-		//num is really an unsigned byte
-		if (number < 0) {
-			number += 256;
-		}
-		this.number = number;
-	}
-
-	/**
-	 * Get the data type for the structure.
-	 * 
-	 * @return the data type for the structure.
-	 */
-	public int getDataType() {
-		return dataType;
-	}
-
-	/**
-	 * Set the numeric data type for the structure.
-	 * 
-	 * @param dataType the dataTtype for the structure.
-	 */
-	public void setDataType(int dataType) {
-		this.dataType = dataType;
-	}
-
-    /**
-     * Get the length of the structure in ints, not counting the length word.
-     *
-     * @return Get the length of the structure in ints (not counting the length word).
-     */
-    public int getLength() {
-        return length;
-    }
-
-    /**
-     * Set the length of the structure in ints, not counting the length word.
-     *
-     * @param length the length of the structure in ints, not counting the length word.
-     */
-    public void setLength(int length) {
-        this.length = length;
-    }
-
-    /**
-     * Get the length of the structure's header in ints. This includes the first header word itself
-     * (which contains the length) and in the case of banks, it also includes the second header word.
-     *
-     * @return Get the length of the structure's header in ints.
-     */
-    public abstract int getHeaderLength();
-
-    /**
-     * Write myself out as a byte array of evio format data
-     * into the given byte array in the specified byte order.
-     *
-     * @return byte array containing evio format data of this bank in currently set byte order
-     */
-    protected abstract void toArray(byte[] bArray, int offset, ByteOrder order);
-
-	/**
-	 * Get the structure tag.
-	 * 
-	 * @return the structure tag.
-	 */
-	public int getTag() {
-		return tag;
-	}
-
-	/**
-	 * Set the structure tag.
-	 * 
-	 * @param tag the structure tag.
-	 */
-	public void setTag(int tag) {
-		this.tag = tag;
-	}
-
-	/**
-	 * Returns the data type as a string.
-	 * 
-	 * @return the data type as a string.
-	 */
-	public String getDataTypeName() {
-		return DataType.getName(dataType);
-	}
-
-	/**
-	 * Returns the data type for data stored in this structure as a <code>DataType</code> enum.
-	 * 
-	 * @return the data type for data stored in this structure as a <code>DataType</code> enum.
-	 * @see DataType
-	 */
-	public DataType getDataTypeEnum() {
-		return DataType.getDataType(dataType);
-	}
-
-	/**
-	 * Obtain a string representation of the structure header.
-	 * 
-	 * @return a string representation of the structure header.
-	 */
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(512);
-		sb.append(String.format("structure length: %d\n", length));
-		sb.append(String.format("data type:   %s\n", getDataTypeName()));
-		sb.append(String.format("tag:         %d\n", tag));
-		return sb.toString();
-	}
-	
-	/**
-	 * Convenience method to return the byte value of an integer. Although
-	 * the parameter is an Integer, use "autoboxing" to pass in a primitive. I.e.,
-	 * byteValue(3) works just fine.
-	 * @param integer the integer whose byte value is needed. Can pass in a primitive int.
-	 * @return the byte value of the integer.
-	 */
-	public byte byteValue(Integer integer) {
-		return integer.byteValue();
-	}
-	
-	/**
-	 * Convenience method to return the short value of an integer. Although
-	 * the parameter is an Integer, use "autoboxing" to pass in a primitive. I.e.,
-	 * shortValue(3345) works just fine.
-	 * @param integer the integer whose short value is needed. Can pass in a primitive int.
-	 * @return the short value of the integer.
-	 */
-	public short shortValue(Integer integer) {
-		return integer.shortValue();
-	}
-
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N BlockHeader.java
--- BlockHeader.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,482 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-
-/**
- * This holds a evio block header, also known as a physical record header. Unfortunately, in versions 2 & 3, evio files
- * impose an anachronistic block structure. The complication that arises is that logical records (events) will
- * sometimes cross physical record boundaries.
- *
- *
- * <code><pre>
- * ############################
- * Evio block header:
- * ############################
- *
- * MSB(31)                          LSB(0)
- * <---  32 bits ------------------------>
- * _______________________________________
- * |            Block Length             |
- * |_____________________________________|
- * |            Block Number             |
- * |_____________________________________|
- * |          Header Length = 8          |
- * |_____________________________________|
- * |               Start                 |
- * |_____________________________________|
- * |                End                  |
- * |_____________________________________|
- * |              Version                |
- * |_____________________________________|
- * |             Reserved 1              |
- * |_____________________________________|
- * |             Reserved 2              |
- * |_____________________________________|
- *
- *
- *      Block Length  = number of ints in block (including this one).
- *                      This is fixed for versions 1-3, generally at 8192 (32768 bytes)
- *      Block Number  = id number
- *      Header Length = number of ints in this header (always 8)
- *      Start         = offset to first event header in block
- *      End           = offset to last data word in block
- *      Version       = evio format version
- *      Reserved 1    = reserved
- *      Reserved 2    = magic number (0xc0da0100) used to check endianness
- *
- * </pre></code>
- *
- *
- * @author heddle
- *
- */
-public class BlockHeader implements IEvioWriter {
-
-	/**
-	 * The maximum block size in 32 bit ints in this (versions 2 & 3) implementation of evio.
-     * There is, in actuality, no limit on size; however, the version 2/3 C library only used
-     * 8192 as the block size.
-	 */
-	public static final int MAX_BLOCK_SIZE = 32768;
-
-	/**
-	 * The magic number, should be the value of <code>magicNumber</code>.
-	 */
-	public static final int MAGIC_NUMBER = 0xc0da0100;
-
-	/**
-	 * The block (physical record) size in 32 bit ints.
-	 */
-	private int size;
-
-	/**
-	 * The block number. In a file, this is usually sequential.
-	 */
-	private int number;
-
-	/**
-	 * The block header length. Should be 8 in all cases, so getting this correct constitutes a check.
-	 */
-	private int headerLength;
-
-	/**
-     * Offset (in ints, relative to start of block) to the start of the first event (logical record) that begins in this
-     * block. For the first event it will just be = 8, the size of the block header. For subsequent physical records it
-     * will generally not be 8. Note that a logical record (event) that spans three blocks (physical records) will have
-     * <code>start = 0</code>.
-     *
-	 */
-	private int start;
-
-	/**
-	 * The number of valid words (header + data) in the block (physical record.) This is normally the same as the block
-	 * size, except for the last block (physical record) in the file. <br>
-	 * NOTE: for evio files, even if end < size (blocksize) for the last block (physical record), the data behind it
-	 * will be padded with zeroes so that the file size is an integer multiple of the block size.
-	 */
-	private int end;
-
-	/**
-	 * The evio version.
-	 */
-	private int version;
-
-	/**
-	 * First reserved word. Sometimes this is used to indicate the ordinal number of the last event that starts
-	 * within this block--but that is not mandated. In that case, if the previous block had a value of
-	 * reserved1 = 6 and this block has a value of 9, then this block contains the end of event 6, all of events
-	 * 7 and 8, and the start of event 9--unless it ends exactly on the end of event 8.<br>
-	 */
-	private int reserved1;
-
-	/**
-	 * This is the magic word: 0xc0da0100 (formerly reserved2). Used to check endianness.
-	 */
-	private int magicNumber;
-
-	/**
-	 * This is not part of the block header proper. It is a position in a memory buffer of the start of the block
-	 * (physical record). It is kept for convenience.
-	 */
-	private int bufferStartingPosition = -1;
-
-    /**
-	 * Get the size of the block (physical record).
-	 * 
-	 * @return the size of the block (physical record) in ints.
-	 */
-	public int getSize() {
-		return size;
-	}
-	
-	/**
-	 * Null constructor initializes all fields to zero.
-	 */
-	public BlockHeader() {
-		size = 0;
-		number = 0;
-		headerLength = 0;
-		start = 0;
-		end = 0;
-		version = 0;
-		reserved1 = 0;
-		magicNumber = 0;
-	}
-	
-    /**
-     * Creates a BlockHeader for evio version 2 format. Only the (block) <code>size</code>
-     * and (block) <clode>number</code> are provided. The other six words, which can be
-     * modified by setters, are initialized to these values:<br>
-     *<ul>
-     *<li><code>headerLength</code> is initialized to 8<br>
-     *<li><code>start</code> is initialized to 8<br>
-     *<li><code>end</code> is initialized to <code>size</code><br>
-     *<li><code>version</code> is initialized to 2<br>
-     *<li><code>reserved1</code> is initialized to 0<br>
-     *<li><code>magicNumber</code> is initialized to <code>MAGIC_NUMBER</code><br>
-     *</ul>
-     * @param size the size of the block in ints.
-     * @param number the block number--usually sequential.
-     */
-    public BlockHeader(int size, int number) {
-        this.size = size;
-        this.number = number;
-        headerLength = 8;
-        start = 8;
-        end = size;
-        version = 2;
-        reserved1 = 0;
-        magicNumber = MAGIC_NUMBER;
-    }
-
-	/**
-	 * Set the size of the block (physical record). Some trivial checking is done.
-	 * 
-	 * @param size the new value for the size, in ints.
-	 * @throws EvioException
-	 */
-	public void setSize(int size) throws EvioException {
-        if ((size < 8) || (size > MAX_BLOCK_SIZE)) {
-			throw new EvioException(String.format("Bad value for size in block (physical record) header: %d", size));
-		}
-
-        // I'm not sure why this restriction is in here - timmer
-        if ((size % 256) != 0) {
-            throw new EvioException(String.format(
-                    "Bad value for size in block (physical record) header: %d (must be multiple of 256 ints)", size));
-        }
-        this.size = size;
-	}
-
-    /**
-     * Get the starting position of the block (physical record.). This is the offset (in ints, relative to start of
-     * block) to the start of the first event (logical record) that begins in this block. For the first event it will
-     * just be = 8, the size of the block header. For subsequent blocks it will generally not be 8. Note that a
-     * an event that spans three blocks (physical records) will have <code>start = 0</code>.
-     *
-     * NOTE: a logical record (event) that spans three blocks (physical records) will have <code>start = 0</code>.
-     *
-     * @return the starting position of the block (physical record.)
-     */
-    public int getStart() {
-        return start;
-    }
-
-    /**
-     * Set the starting position of the block (physical record.). This is the offset (in ints, relative to start of
-     * block) to the start of the first event (logical record) that begins in this block. For the first event it will
-     * just be = 8, the size of the block header. For subsequent blocks it will generally not be 8. Some trivial
-     * checking is done. Note that an event that spans three blocks (physical records) will have
-     * <code>start = 0</code>.
-     *
-     * NOTE: a logical record (event) that spans three blocks (physical records) will have <code>start = 0</code>.
-     *
-     * @param start the new value for the start.
-     * @throws EvioException
-     */
-    public void setStart(int start) throws EvioException {
-        if ((start < 0) || (start > MAX_BLOCK_SIZE)) {
-            throw new EvioException(String.format("Bad value for start in block (physical record) header: %d", start));
-        }
-        this.start = start;
-    }
-
-	/**
-	 * Get the ending position of the block (physical record.) This is the number of valid words (header + data) in the
-	 * block (physical record.) This is normally the same as the block size, except for the last block (physical record)
-	 * in the file.<br>
-	 * NOTE: for evio files, even if end < size (blocksize) for the last block (physical record), the data behind it
-	 * will be padded with zeroes so that the file size is an integer multiple of the block size.
-	 * 
-	 * @return the ending position of the block (physical record.)
-	 */
-	public int getEnd() {
-		return end;
-	}
-
-	/**
-	 * Set the ending position of the block (physical record.) This is the number of valid words (header + data) in the
-	 * block (physical record.) This is normally the same as the block size, except for the last block (physical record)
-	 * in the file. Some trivial checking is done.<br>
-	 * NOTE: for evio files, even if end < size (blocksize) for the last block (physical record), the data behind it
-	 * will be padded with zeroes so that the file size is an integer multiple of the block size.
-	 * 
-	 * @param end the new value for the end.
-	 * @throws EvioException
-	 */
-	public void setEnd(int end) throws EvioException {
-		if ((end < 8) || (end > MAX_BLOCK_SIZE)) {
-			throw new EvioException(String.format("Bad value for end in block (physical record) header: %d", end));
-		}
-		this.end = end;
-	}
-
-	/**
-	 * Get the block number for this block (physical record). In a file, this is usually sequential.
-	 * 
-	 * @return the block number for this block (physical record).
-	 */
-	public int getNumber() {
-		return number;
-	}
-
-	/**
-	 * Set the block number for this block (physical record). In a file, this is usually sequential. This is not
-	 * checked.
-	 * 
-	 * @param number the number of the block (physical record).
-	 */
-	public void setNumber(int number) {
-		this.number = number;
-	}
-
-	/**
-	 * Get the block header length, in ints. This should be 8.
-	 * 
-	 * @return the block header length. This should be 8.
-	 */
-	public int getHeaderLength() {
-		return headerLength;
-	}
-
-	/**
-	 * Set the block header length, in ints. This should be 8. However, since this is usually read as part of reading
-	 * the physical record header, it is a good check to have a setter rather than just fix its value at 8.
-	 * 
-	 * param headerLength the new block header length. This should be 8.
-	 * 
-	 * @throws EvioException if headerLength is not 8.
-	 */
-	public void setHeaderLength(int headerLength) throws EvioException {
-		if (headerLength != 8) {
-			String message = "Bad Block (Physical Record) Header Length: " + headerLength;
-			throw new EvioException(message);
-		}
-		this.headerLength = headerLength;
-	}
-
-	/**
-	 * Get the evio version of the block (physical record) header.
-	 * 
-	 * @return the evio version of the block (physical record) header.
-	 */
-	public int getVersion() {
-		return version;
-	}
-
-	/**
-	 * Sets the evio version. Should be 2 or 3 but no check is performed here, see
-     * {@link EvioFile#nextBlockHeader()}.
-	 * 
-	 * @param version the evio version of evio.
-	 */
-	public void setVersion(int version) {
-		this.version = version;
-	}
-
-	/**
-	 * Get the first reserved word in the block (physical record) header.
-	 * 
-	 * @return the first reserved word in the block (physical record).
-	 */
-	public int getReserved1() {
-		return reserved1;
-	}
-
-	/**
-	 * Sets the value of reserved 1.
-	 * 
-	 * @param reserved1 the value for reserved1.
-	 */
-	public void setReserved1(int reserved1) {
-		this.reserved1 = reserved1;
-	}
-
-	/**
-	 * Get the magic number the block (physical record) header which should be 0xc0da0100.
-     * Formerly this location in the header was called "reserved2".
-	 * 
-	 * @return the magic number in the block (physical record).
-	 */
-	public int getMagicNumber() {
-		return magicNumber;
-	}
-
-	/**
-	 * Sets the value of magicNumber. This should match the constant MAGIC_NUMBER.
-     * If it doesn't, some obvious possibilities: <br>
-	 * 1) The evio data (perhaps from a file) is screwed up.<br>
-	 * 2) The reading algorithm is screwed up. <br>
-	 * 3) The endianess is not being handled properly.
-	 * 
-	 * @param magicNumber the new value for magic number.
-	 * @throws EvioException
-	 */
-	public void setMagicNumber(int magicNumber) throws EvioException {
-		if (magicNumber != MAGIC_NUMBER) {
-			throw new EvioException(String.format("Value for magicNumber %8x does not match MAGIC_NUMBER 0xc0da0100.",
-                                                  magicNumber));
-		}
-		this.magicNumber = magicNumber;
-	}
-
-	/**
-	 * Obtain a string representation of the block (physical record) header.
-	 * 
-	 * @return a string representation of the block (physical record) header.
-	 */
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(512);
-		sb.append(String.format("block size:    %d\n", size));
-		sb.append(String.format("number:        %d\n", number));
-		sb.append(String.format("headerLen:     %d\n", headerLength));
-		sb.append(String.format("start:         %d\n", start));
-		sb.append(String.format("end:           %d\n", end));
-		sb.append(String.format("version:       %d\n", version));
-		sb.append(String.format("reserved1:     %d\n", reserved1));
-		sb.append(String.format("magicNumber:   %8x\n", magicNumber));
-		sb.append(String.format(" *buffer start:  %d\n", getBufferStartingPosition()));
-		sb.append(String.format(" *next   start:  %d\n", nextBufferStartingPosition()));
-		return sb.toString();
-	}
-
-    /**
-     * Get the position in the buffer (in bytes) of this block's last data word.<br>
-     *
-     * @return the position in the buffer (in bytes) of this block's last data word.
-     */
-    public int getBufferEndingPosition() {
-        return bufferStartingPosition + 4*end;
-    }
-
-    /**
-     * Get the starting position in the buffer (in bytes) from which this header was read--if that happened.<br>
-     * This is not part of the block header proper. It is a position in a memory buffer of the start of the block
-     * (physical record). It is kept for convenience. It is up to the reader to set it.
-     *
-     * @return the starting position in the buffer (in bytes) from which this header was read--if that happened.
-     */
-    public int getBufferStartingPosition() {
-        return bufferStartingPosition;
-    }
-
-	/**
-	 * Set the starting position in the buffer (in bytes) from which this header was read--if that happened.<br>
-	 * This is not part of the block header proper. It is a position in a memory buffer of the start of the block
-	 * (physical record). It is kept for convenience. It is up to the reader to set it.
-	 * 
-	 * @param bufferStartingPosition the starting position in the buffer from which this header was read--if that
-	 *            happened.
-	 */
-	public void setBufferStartingPosition(int bufferStartingPosition) {
-		this.bufferStartingPosition = bufferStartingPosition;
-	}
-
-	/**
-	 * Determines where the start of the next block (physical record) header in some buffer is located (in bytes).
-     * This assumes the start position has been maintained by the object performing the buffer read.
-	 * 
-	 * @return the start of the next block (physical record) header in some buffer is located (in bytes).
-	 */
-	public int nextBufferStartingPosition() {
-		return bufferStartingPosition + 4 * size;
-	}
-
-	/**
-	 * Determines where the start of the first event (logical record) in this block (physical record) is located
-     * (in bytes). This assumes the start position has been maintained by the object performing the buffer read.
-	 * 
-	 * @return where the start of the first event (logical record) in this block (physical record) is located
-     *         (in bytes). Returns 0 if start is 0, signaling that this entire physical record is part of a
-     *         logical record that spans at least three physical records.
-	 */
-	public int firstEventStartingPosition() {
-        if (start == 0) {
-			return 0;
-		}
-		return bufferStartingPosition + 4 * start;
-	}
-
-	/**
-	 * Gives the bytes remaining in this block (physical record) given a buffer position. The position is an absolute
-	 * position in a byte buffer. This assumes that the absolute position in <code>bufferStartingPosition</code> is
-	 * being maintained properly by the reader.
-	 * 
-	 * @param position the absolute current position is a byte buffer.
-	 * @return the number of bytes remaining in this block (physical record.)
-	 * @throws EvioException
-	 */
-	public int bytesRemaining(int position) throws EvioException {
-		if (position < bufferStartingPosition) {
-			throw new EvioException("Provided position is less than buffer starting position.");
-		}
-
-		int nextBufferStart = nextBufferStartingPosition();
-//System.out.println("bytesRemaining: position = " + position + ", next buffer start = " + nextBufferStart);
-		if (position > nextBufferStart) {
-			throw new EvioException("Provided position beyond buffer end position.");
-		}
-
-		return nextBufferStart - position;
-	}
-	
-	/**
-	 * Write myself out a byte buffer. This write is relative--i.e., it uses the current position of the buffer.
-	 * 
-	 * @param byteBuffer the byteBuffer to write to.
-	 * @return the number of bytes written, which for a BlockHeader is 32.
-	 */
-	@Override
-	public int write(ByteBuffer byteBuffer) {
-		byteBuffer.putInt(size);
-		byteBuffer.putInt(number);
-		byteBuffer.putInt(headerLength); // should always be 8
-		byteBuffer.putInt(start);
-		byteBuffer.putInt(end);
-		byteBuffer.putInt(version);
-		byteBuffer.putInt(reserved1);
-		byteBuffer.putInt(magicNumber);
-		return 32;
-	}
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N ByteDataTransformer.java
--- ByteDataTransformer.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,510 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.*;
-
-/**
- * This utility class contains methods for transforming a raw byte array into arrays of
- * other types such as int and double. It also contains a method for byte swapping evio
- * format data as well as other handy methods.
- * 
- * @author heddle
- * @author timmer
- * @author wolin
- *
- */
-public class ByteDataTransformer {
-
-	/**
-	 * Converts a byte array into an int array.
-	 * 
-     * @param bytes the byte array.
-     * @param byteOrder the endianness of the data in the byte array,
-     *       {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-	 * @return the raw bytes converted into an int array.
-	 */
-	public static int[] getAsIntArray(byte bytes[], ByteOrder byteOrder) {
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		int intsize = bytes.length / 4;
-		int array[] = new int[intsize];
-		for (int i = 0; i < intsize; i++) {
-			array[i] = byteBuffer.getInt();
-		}
-		return array;
-	}
-	
-	/**
-	 * Converts a byte array into an short array.
-	 * 
-	 * @param bytes the byte array.
-     * @param byteOrder the endianness of the data in the byte array,
-     *       {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-	 * @return the raw bytes converted into an int array.
-	 */
-	public static short[] getAsShortArray(byte bytes[], ByteOrder byteOrder) {
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		int shortsize = bytes.length / 2;
-		short array[] = new short[shortsize];
-		for (int i = 0; i < shortsize; i++) {
-			array[i] = byteBuffer.getShort();
-		}
-		return array;
-	}
-
-	
-	/**
-	 * Converts a byte array into a long array.
-	 * 
-	 * @param bytes the byte array.
-     * @param byteOrder the endianness of the data in the byte array,
-     *       {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-	 * @return the raw bytes converted into a long array.
-	 */
-	public static long[] getAsLongArray(byte bytes[], ByteOrder byteOrder) {
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		int longsize = bytes.length / 8;
-		long array[] = new long[longsize];
-		for (int i = 0; i < longsize; i++) {
-			array[i] = byteBuffer.getLong();
-		}
-		return array;
-	}
-
-	/**
-	 * Converts a byte array into a double array.
-	 * 
-	 * @param bytes the byte array.
-     * @param byteOrder the endianness of the data in the byte array,
-     *       {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-	 * @return the raw bytes converted into a double array.
-	 */
-	public static double[] getAsDoubleArray(byte bytes[], ByteOrder byteOrder) {
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		int doublesize = bytes.length / 8;
-		double array[] = new double[doublesize];
-		for (int i = 0; i < doublesize; i++) {
-			array[i] = byteBuffer.getDouble();
-		}
-		return array;
-	}
-	
-	/**
-	 * Converts a byte array into a float array.
-	 * 
-	 * @param bytes the byte array.
-     * @param byteOrder the endianness of the data in the byte array,
-     *       {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-	 * @return the raw bytes converted into a float array.
-	 */
-	public static float[] getAsFloatArray(byte bytes[], ByteOrder byteOrder) {
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		int floatsize = bytes.length / 4;
-		float array[] = new float[floatsize];
-		for (int i = 0; i < floatsize; i++) {
-			array[i] = byteBuffer.getFloat();
-		}
-		return array;
-	}
-
-    /**
-     * Copies an integer value into 4 bytes of a byte array.
-     * @param intVal integer value
-     * @param b byte array
-     * @param off offset into the byte array
-     */
-    public static final void intToBytes(int intVal, byte[] b, int off) {
-        b[off]   = (byte) ((intVal & 0xff000000) >>> 24);
-        b[off+1] = (byte) ((intVal & 0x00ff0000) >>> 16);
-        b[off+2] = (byte) ((intVal & 0x0000ff00) >>>  8);
-        b[off+3] = (byte)  (intVal & 0x000000ff);
-    }
-
-
-    /**
-     * Copies a short value into 2 bytes of a byte array.
-     * @param val short value
-     * @param b byte array
-     * @param off offset into the byte array
-     */
-    public static final void shortToBytes(short val, byte[] b, int off) {
-      b[off]   = (byte) ((val & 0x0000ff00) >>>  8);
-      b[off+1] = (byte)  (val & 0x000000ff);
-    }
-
-
-    /**
-     * Copies a 2-byte short value into a 4-byte int while preserving bit pattern.
-     * In other words, it treats the short as an unsigned value. The resulting int
-     * does NOT undergo sign extension (bits of highest 2 bytes are not all ones),
-     * and will not be a negative number.
-     *
-     * @param shortVal short value considered to be unsigned
-     * @return the equivalent int value
-     */
-    public static final int shortBitsToInt(short shortVal) {
-        return (shortVal & 0x0000ffff);
-    }
-
-
-    /**
-     * Copies a 1-byte byte value into a 4-byte int while preserving bit pattern.
-     * In other words, it treats the byte as an unsigned value. The resulting int
-     * does NOT undergo sign extension (bits of highest 3 bytes are not all ones),
-     * and will not be a negative number.
-     *
-     * @param byteVal byte value considered to be unsigned
-     * @return the equivalent int value
-     */
-    public static final int byteBitsToInt(byte byteVal) {
-        return (byteVal & 0x000000ff);
-    }
-
-
-    //--------------------------------
-    // EVIO FORMAT DATA SWAPPING
-    //--------------------------------
-
-    /**
-     * Swaps evio format data (event or bank) contained in a ByteBuffer.
-     * NOTE: the byte order of the source buffer must be set properly by
-     * the caller using {@link ByteBuffer#order(java.nio.ByteOrder)}.
-     *
-     * @param srcBuf   evio data (event or bank) to be swapped
-     * @param destBuf  destination for swapped evio data; if null, swap in place
-     * @throws EvioException if data not in evio format
-     */
-    public static void swap(ByteBuffer srcBuf, ByteBuffer destBuf) throws EvioException {
-        ByteOrder srcOrder  = srcBuf.order();
-        ByteOrder destOrder = ByteOrder.BIG_ENDIAN;
-
-        if (srcOrder == ByteOrder.BIG_ENDIAN) {
-            destOrder = ByteOrder.LITTLE_ENDIAN;
-        }
-
-        // writing into this buffer will automatically swap bytes
-        if (destBuf != null) {
-            destBuf.order(destOrder);
-        }
-
-        try {
-            swapBank(srcBuf, destBuf);
-        }
-        catch (BufferOverflowException e) {
-            throw new EvioException("Data not in evio format", e);
-        }
-        catch (BufferUnderflowException e) {
-            throw new EvioException("Data not in evio format", e);
-        }
-        catch (IndexOutOfBoundsException e) {
-            throw new EvioException("Data not in evio format", e);
-        }
-
-        // if swapping in place, set buffer's new byte order now that it's completely swapped
-        if (destBuf == null) {
-            srcBuf.order(destOrder);
-        }
-    }
-
-    /**
-     * Swaps evio event or bank data.
-     *
-     * @param bank  evio data (event or bank) to be swapped
-     * @return bank object with swapped data
-     * @throws EvioException  if data not in evio format
-     */
-    public static EvioEvent swap(EvioBank bank) throws EvioException {
-        ByteOrder newOrder = (bank.getByteOrder() == ByteOrder.BIG_ENDIAN) ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN;
-
-        byte[] array = bank.toArray();
-        ByteBuffer buf = ByteBuffer.wrap(array);
-        buf.order(bank.getByteOrder());
-
-        try {
-            swapBank(buf, null);
-        }
-        catch (BufferOverflowException e) {
-            throw new EvioException("Data not in evio format", e);
-        }
-        catch (BufferUnderflowException e) {
-            throw new EvioException("Data not in evio format", e);
-        }
-        catch (IndexOutOfBoundsException e) {
-            throw new EvioException("Data not in evio format", e);
-        }
-
-        ByteParser parser = new ByteParser();
-        buf.rewind();
-        // set buf to new byte order now that it's completely swapped
-        buf.order(newOrder);
-        return parser.parseEvent(buf);
-    }
-
-    /**
-     * Copies buffer of 4-byte integers.
-     *
-     * @param srcBuf   input data buffer
-     * @param length   number of integer words to copy
-     * @param destBuf  destination data buffer; if null, swap in place
-     */
-    private static void copyData(ByteBuffer srcBuf, int length, ByteBuffer destBuf) {
-
-        if (destBuf == null) return;
-
-        int numBytes = 4*length;
-        byte[] bytes = new byte[numBytes];
-        
-        srcBuf.get(bytes, 0, numBytes);
-        destBuf.put(bytes, 0, numBytes);
-
-        return;
-    }
-
-    /**
-     * Swaps buffer of 4-byte integers.
-     *
-     * @param srcBuf   input data buffer
-     * @param length   number of integer words to swap
-     * @param destBuf  destination data buffer; if null, swap in place
-     */
-    private static void swapIntArray(ByteBuffer srcBuf, int length, ByteBuffer destBuf) {
-
-        if (destBuf == null) {
-            int pos;
-            for (int i = 0; i < length; i++) {
-                pos = srcBuf.position();
-                srcBuf.putInt(Integer.reverseBytes(srcBuf.getInt(pos)));
-            }
-        }
-        else {
-            for (int i = 0; i < length; i++) {
-                destBuf.putInt(srcBuf.getInt());
-            }
-        }
-        return;
-    }
-
-    /**
-     * Swaps 8-byte longs packed into 4-byte integer buffer.
-     *
-     * @param srcBuf   input data buffer
-     * @param length   number of integer words to swap
-     * @param destBuf  destination data buffer; if null, swap in place
-     */
-    private static void swapLongArray(ByteBuffer srcBuf, int length, ByteBuffer destBuf) {
-        int numLongs = length/2;
-
-        if (destBuf == null) {
-            int pos;
-            for (int i = 0; i < numLongs; i++) {
-                pos = srcBuf.position();
-                srcBuf.putLong(Long.reverseBytes(srcBuf.getLong(pos)));
-            }
-        }
-        else {
-            for (int i = 0; i < numLongs; i++) {
-                destBuf.putLong(srcBuf.getLong());
-            }
-        }
-        return;
-    }
-
-    /**
-     * Swaps 2-byte shorts packed in 4-byte integer buffer.
-     *
-     * @param srcBuf   input data buffer
-     * @param length   number of integer words to swap
-     * @param destBuf  destination data buffer; if null, swap in place
-     */
-    private static void swapShortArray(ByteBuffer srcBuf, int length, ByteBuffer destBuf) {
-        int numShorts = 2*length;
-
-        if (destBuf == null) {
-            int pos;
-            for (int i = 0; i < numShorts; i++) {
-                pos = srcBuf.position();
-                srcBuf.putShort(Short.reverseBytes(srcBuf.getShort(pos)));
-            }
-        }
-        else {
-            for (int i = 0; i < numShorts; i++) {
-                destBuf.putShort(srcBuf.getShort());
-            }
-        }
-        return;
-    }
-
-    /**
-     * Swap an evio bank.
-     *
-     * @param srcBuf   evio bank data to swap
-     * @param destBuf  destination buffer for swapped bank; if null, swap in place
-     * @return size of data (in 4 byte ints) contained in bank plus header
-     * @throws EvioException if data not in evio format
-     */
-    private static int swapBank(ByteBuffer srcBuf, ByteBuffer destBuf) throws EvioException {
-
-        // parse 2 header ints to find data length & type
-        srcBuf.mark();
-        int dataLength = srcBuf.getInt() - 1;
-        DataType dataType = DataType.getDataType((srcBuf.getInt() >> 8) & 0xff);
-        srcBuf.reset();
-
-        // swap 2 header ints
-        swapIntArray(srcBuf, 2, destBuf); // does not advance position
-
-        // swap data following header
-        swapData(srcBuf, dataType, dataLength, destBuf);
-
-        // return total length of this bank including both header ints
-        return dataLength + 2;
-    }
-
-    /**
-     * Swap an evio segment.
-     *
-     * @param srcBuf   byte buffer to swap
-     * @param destBuf  destination buffer for swapped event; if null, swap in place
-     * @return size of data (in 4 byte ints) contained in segment plus header
-     * @throws EvioException if data not in evio format
-     */
-    private static int swapSegment(ByteBuffer srcBuf, ByteBuffer destBuf) throws EvioException {
-
-        // parse 1 header int to find data length & type
-        srcBuf.mark();
-        int d = srcBuf.getInt();
-        srcBuf.reset();
-        int dataLength = (d & 0xffff);
-        DataType dataType = DataType.getDataType((d >> 16) & 0xff);
-
-        // swap 1 header int
-        swapIntArray(srcBuf, 1, destBuf);
-
-        // swap data following header
-        swapData(srcBuf, dataType, dataLength, destBuf);
-
-        // return total length of this bank including header int
-        return dataLength + 1;
-    }
-
-
-    /**
-     * Swap an evio tagsegment.
-     *
-     * @param srcBuf   byte buffer to swap
-     * @param destBuf  destination buffer for swapped event; if null, swap in place
-     * @return size of data (in 4 byte ints) contained in tagsegment plus header
-     * @throws EvioException if data not in evio format
-     */
-    private static int swapTagSegment(ByteBuffer srcBuf, ByteBuffer destBuf) throws EvioException {
-
-        // parse 1 header int to find data length & type
-        srcBuf.mark();
-        int d = srcBuf.getInt();
-        srcBuf.reset();
-        int dataLength = (d & 0xffff);
-        DataType dataType = DataType.getDataType((d >> 16) & 0xf);
-
-        // swap 1 header int
-        swapIntArray(srcBuf, 1, destBuf);
-
-        // swap data following header
-        swapData(srcBuf, dataType, dataLength, destBuf);
-
-        // return total length of this bank including header int
-        return dataLength + 1;
-    }
-
-
-    /**
-     * Handle the swapping of evio data or container of evio data.
-     *
-     * @param srcBuf   byte buffer to swap
-     * @param type     type of data in the data buffer
-     * @param length   length of data (4 byte ints) to swap
-     * @param destBuf  destination buffer for swapped event; if null, swap in place
-     * @throws EvioException if data not in evio format
-     */
-    private static void swapData(ByteBuffer srcBuf, DataType type, int length,
-                                 ByteBuffer destBuf) throws EvioException {
-
-        int len = 0;
-
-        // A container (bank, segment, or tagsegment) to be swapped has called this method.
-        // We switch on the type of data or containers held by this top-level container.
-        // If data is held, just swap it here or call swap<Fragment> methods if containers
-        // are held.
-
-        switch (type) {
-
-            // 32 bit swap
-            case INT32:
-            case UINT32:
-            case FLOAT32:
-                swapIntArray(srcBuf, length, destBuf);
-                break;
-
-            // 16 bit swap
-            case SHORT16:
-            case USHORT16:
-                swapShortArray(srcBuf, length, destBuf);
-                break;
-
-            // 64 bit swap
-            case LONG64:
-            case ULONG64:
-            case DOUBLE64:
-                swapLongArray(srcBuf, length, destBuf);
-                break;
-
-            // no swap
-            case UNKNOWN32:
-            case CHAR8:
-            case UCHAR8:
-            case CHARSTAR8:
-                copyData(srcBuf, length, destBuf);
-                break;
-
-            // container of banks
-            case BANK:
-            case ALSOBANK:
-                // The calling container is a bank of banks and may contain
-                // multiple banks, each of which need to be swapped.
-                while (len < length) {
-                    len += swapBank(srcBuf, destBuf);
-                }
-                if (len != length) {
-                    throw new EvioException("Data not in evio format");
-                }
-                break;
-
-            // container of segments
-            case SEGMENT:
-            case ALSOSEGMENT:
-                while (len < length) {
-                    len += swapSegment(srcBuf, destBuf);
-                }
-                if (len != length) {
-                    throw new EvioException("Data not in evio format");
-                }
-                break;
-
-            // container of tagsegments
-            case TAGSEGMENT:
-            case ALSOTAGSEGMENT:
-                while (len < length) {
-                    len += swapTagSegment(srcBuf, destBuf);
-                }
-                if (len != length) {
-                    throw new EvioException("Data not in evio format");
-                }
-                break;
-
-            // unknown type, just copy
-            default:
-                copyData(srcBuf, length, destBuf);
-                break;
-        }
-
-        return;
-    }
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N ByteParser.java
--- ByteParser.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,485 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.io.DataInputStream;
-import java.io.IOException;
-
-import javax.swing.event.EventListenerList;
-import javax.swing.tree.DefaultTreeModel;
-
-/**
- * This class controls the creating of an event by the parsing of a byte array.
- * Unlike the EventParser class, it does not use a singleton pattern because the parsing of bytes is used primarily
- * for reading data sent over the network or from an ET system and is used in a multithreaded environment.
- * This class acts like EvioFile and EventParser together, except the data in our case is obtained by reading
- * IO streams (eg. from a socket). Thus, it's much simpler than reading a file and the result is we have a
- * byte array to parse.<p>
- *
- * @author timmer
- */
-public class ByteParser {
-
-    /**
-     * Listener list for structures (banks, segments, tagsegments) encountered while processing an event.
-     */
-    private EventListenerList evioListenerList;
-
-    /**
-     * This flag determines whether notification of listeners is active. Normally it is. But in some cases it should be
-     * temporarily suspended. For example, in a "goto event" process, the listeners will not be notified of the
-     * intervening events as the file is scanned to get to the target event.
-     */
-    protected boolean notificationActive = true;
-
-    /**
-      * A single global structure filter. This may prove to be a limitation: perhaps we want one per listener.
-      */
-    private IEvioFilter evioFilter;
-
-    /**
-     * No-arg constructor.
-     */
-    public ByteParser() { }
-
-
-    /**
-     * This is the workhorse method for parsing the byte array. It will drill down and uncover all structures
-     * (banks, segments, and tagsegments) and notify any interested listeners in a SAX-Like manner. <br>
-     * Note: applications may choose not to provide a listener. In that case, when the event is parsed, its structures
-     * may be accessed through the event's tree model, i.e., via <code>event.getTreeModel()</code>.
-     *
-     * @param bytes     the binary data to be parsed.
-     * @param byteOrder the byte order of the binary array, either
-     *        {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-     * @return an EvioEvent object created from the byte array.
-     * @throws EvioException if data not in evio format.
-     */
-    public EvioEvent parseEvent(byte[] bytes, ByteOrder byteOrder) throws EvioException {
-        // wrap the byte array in a ByteBuffer for ease of parsing & automatic byte swapping
-        ByteBuffer buf = ByteBuffer.wrap(bytes).order(byteOrder);
-        return parseEvent(buf);
-    }
-
-
-    /**
-     * This is the workhorse method for parsing the byte buffer. It will drill down and uncover all structures
-     * (banks, segments, and tagsegments) and notify any interested listeners in a SAX-Like manner. <br>
-     * Note: applications may choose not to provide a listener. In that case, when the event is parsed, its structures
-     * may be accessed through the event's tree model, i.e., via <code>event.getTreeModel()</code>.
-     *
-     * @param buf buffer of binary data to parse.
-     * @return an EvioEvent object created from the byte array.
-     * @throws EvioException if data not in evio format.
-     */
-    public EvioEvent parseEvent(ByteBuffer buf) throws EvioException {
-        return (EvioEvent) parseBank(buf, null, null);
-    }
-
-
-    /**
-     * This is a method for reading data over a DataInputStream and parsing it into an EvioEvent.
-     *
-     * @param in data input stream containing binary data to parse in network byte order.
-     * @param byteOrder the byte order of the input bytes, either
-     *        {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-     * @return an EvioEvent object created from the data input stream.
-     * @throws IOException if IO error.
-     * @throws EvioException if data not in evio format.
-     */
-    public EvioEvent readEvent(DataInputStream in, ByteOrder byteOrder) throws IOException, EvioException {
-        int length, lengthRead;
-        length = lengthRead = in.readInt();
-        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {
-            length = Integer.reverseBytes(lengthRead);
-        }
-
-        byte[] buffer = new byte[4*(length + 1)];
-
-        in.readFully(buffer, 4, 4*length);
-
-        // put length at beginning of array
-        ByteDataTransformer.intToBytes(lengthRead, buffer, 0);
-
-        return parseEvent(buffer, byteOrder);
-    }
-
-
-    /**
-     * Parse a ByteBuffer as an evio bank.
-     *
-     * @param buf buffer of binary data to parse.
-     * @param event the EvioEvent object being created.
-     * @param parent the parent of the bank being created.
-     * @return the EvioBank object created from the byte buffer.
-     * @throws EvioException if data not in evio format.
-     */
-    private BaseStructure parseBank(ByteBuffer buf, EvioEvent event, BaseStructure parent)
-            throws EvioException {
-
-        // create & fill bank header
-        BankHeader header = createBankHeader(buf);
-
-        // create bank
-        EvioBank bank;
-
-        // if no event created yet, we're top level so create it
-        if (event == null) {
-            // create event which is top-level bank
-            event = new EvioEvent(header);
-            event.treeModel = new DefaultTreeModel(event);
-            bank = event;
-        }
-        else {
-            // create bank and put it in parent
-            bank = new EvioBank(header);
-            bank.setParent(parent);
-            event.insert(bank, parent);
-        }
-
-        return parseStructure(buf, event, bank);
-    }
-
-
-
-    /**
-     * Parse a ByteBuffer as an evio segment.
-     *
-     * @param buf buffer of binary data to parse.
-     * @param event the EvioEvent object being created.
-     * @param parent the parent of the segment being created.
-     * @return the EvioSegment object created from the byte buffer.
-     * @throws EvioException if data not in evio format.
-     */
-    private BaseStructure parseSegment(ByteBuffer buf, EvioEvent event, BaseStructure parent)
-            throws EvioException {
-
-        // create & fill segment header
-        SegmentHeader header = createSegmentHeader(buf);
-
-        // create segment and put it in parent
-        EvioSegment segment = new EvioSegment(header);
-        segment.setParent(parent);
-        event.insert(segment, parent);
-
-        return parseStructure(buf, event, segment);
-    }
-
-
-    /**
-     * Parse a ByteBuffer as an evio tag segment.
-     *
-     * @param buf buffer of binary data to parse.
-     * @param event the EvioEvent object being created.
-     * @param parent the parent of the tag segment being created.
-     * @return the EvioTagSegment object created from the byte buffer.
-     * @throws EvioException if data not in evio format.
-     */
-    private BaseStructure parseTagSegment(ByteBuffer buf, EvioEvent event, BaseStructure parent)
-            throws EvioException {
-
-        // create & fill tag segment header
-        TagSegmentHeader header = createTagSegmentHeader(buf);
-
-        // create tag segment and put it in parent
-        EvioTagSegment tagSegment = new EvioTagSegment(header);
-        tagSegment.setParent(parent);
-        event.insert(tagSegment, parent);
-
-        return parseStructure(buf, event, tagSegment);
-    }
-
-
-    /**
-     * Parse the evio structure (bank, segment, or tagsegment).
-     *
-     * @param buf buffer of binary data to parse.
-     * @param event the EvioEvent object being created.
-     * @param structure the structure object being created (bank, segment, or tagsegment)
-     * @return object passed in as structure
-     * @throws EvioException if data not in evio format.
-     */
-    private BaseStructure parseStructure(ByteBuffer buf, EvioEvent event, BaseStructure structure)
-            throws EvioException {
-
-        BaseStructureHeader header = structure.getHeader();
-
-        // save position (before raw data) for returning to later
-        buf.mark();
-
-        // length of non-header (raw) data in 32-bit ints
-        int dataLen = header.getLength() + 1 - header.getHeaderLength();
-
-        // store raw bytes in structure
-        byte[] bytes = new byte[4*dataLen];
-        buf.get(bytes, 0, bytes.length);
-        structure.setRawBytes(bytes);
-        structure.setByteOrder(buf.order());
-
-        // Does the present structure contain structures? (as opposed to a leaf, which contains primitives). If
-        // it is a leaf (condition == true), we are done. That will leave the raw bytes in the "leaf" structures
-        // (e.g., a bank of ints) -- which will be interpreted by the various "get data" methods.
-        if (!header.getDataTypeEnum().isStructure()) {
-            // notify the listeners
-            notifyEvioListeners(event, structure);
-            return structure;
-        }
-
-        // Move buffer position before raw data since the raw
-        // data is an evio container and needs to be parsed.
-        buf.reset();
-
-        // parse structures contained in raw data
-        parseData(buf, header.getDataTypeEnum(), dataLen, event, structure);
-
-        // return same structure passed in
-        return structure;
-    }
-
-
-    /**
-     * Create a bank header from the next eight bytes of the byte buffer.
-     *
-     * @param byteBuffer the byte buffer, probably from a bank that encloses this new bank.
-     * @return the new header.
-     */
-    private BankHeader createBankHeader(ByteBuffer byteBuffer) {
-        BankHeader header = new BankHeader();
-        header.setLength(byteBuffer.getInt());
-
-        if (byteBuffer.order() == ByteOrder.BIG_ENDIAN) {
-            // interested in bit pattern, not negative numbers
-            header.setTag(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setNumber(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-        }
-        else {
-            header.setNumber(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setTag(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-        }
-        return header;
-    }
-
-
-    /**
-     * Create a segment header from the next four bytes of the byte buffer.
-     *
-     * @param byteBuffer the byte buffer, probably from a bank that encloses this new segment.
-     * @return the new header.
-     */
-    private SegmentHeader createSegmentHeader(ByteBuffer byteBuffer) {
-        SegmentHeader header = new SegmentHeader();
-
-        if (byteBuffer.order() == ByteOrder.BIG_ENDIAN) {
-            header.setTag(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-        }
-        else {
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setTag(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-        }
-
-        return header;
-    }
-
-
-    /**
-     * Create a tag segment header from the next four bytes of the byte buffer.
-     *
-     * @param byteBuffer the byte buffer, probably from a bank that encloses this new tag segment.
-     * @return the new header.
-     */
-    private TagSegmentHeader createTagSegmentHeader(ByteBuffer byteBuffer) {
-        TagSegmentHeader header = new TagSegmentHeader();
-
-        int temp;
-
-        if (byteBuffer.order() == ByteOrder.BIG_ENDIAN) {
-            temp = ByteDataTransformer.shortBitsToInt(byteBuffer.getShort());
-            header.setTag(temp >>> 4);
-            header.setDataType(temp & 0xF);
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-        }
-        else {
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-            temp = ByteDataTransformer.shortBitsToInt(byteBuffer.getShort());
-            header.setTag(temp >>> 4);
-            header.setDataType(temp & 0xF);
-        }
-
-        return header;
-    }
-
-
-    /**
-     * Handle parsing raw data bytes into containers of data.
-     *
-     * @param buf    the buffer of binary data to parse.
-     * @param type   the type of container in the data buffer.
-     * @param length the length of data in the data buffer to be parsed for these containers.
-     * @param event  the EvioEvent object being created.
-     * @param parent the parent of the structure (banks, segments, or tagsegments) being created.
-     * @throws EvioException if data not in evio format.
-     */
-    private void parseData(ByteBuffer buf, DataType type, int length, EvioEvent event, BaseStructure parent)
-            throws EvioException {
-
-        int len = 0;
-
-        switch (type) {
-
-            // parent is container of banks
-            case BANK:
-            case ALSOBANK:
-                // The calling container is a bank of banks and may contain
-                // multiple banks, each of which need to be parsed.
-                while (len < length) {
-                    BaseStructure bank = parseBank(buf, event, parent);
-                    len += bank.getHeader().getLength() + 1;
-                }
-                if (len != length) {
-                    throw new EvioException("Data not in evio format");
-                }
-
-                break;
-
-            // parent is container of segments
-            case SEGMENT:
-            case ALSOSEGMENT:
-                while (len < length) {
-                    BaseStructure seg = parseSegment(buf, event, parent);
-                    len += seg.getHeader().getLength() + 1;
-                }
-                if (len != length) {
-                    throw new EvioException("Data not in evio format");
-                }
-                break;
-
-            // parent is container of tagsegments
-            case TAGSEGMENT:
-            case ALSOTAGSEGMENT:
-                while (len < length) {
-                    BaseStructure tag = parseTagSegment(buf, event, parent);
-                    len += tag.getHeader().getLength() + 1;
-                }
-                if (len != length) {
-                    throw new EvioException("Data not in evio format");
-                }
-                break;
-
-            // non-container type, do nothing
-            default:
-                break;
-        }
-
-        // notify the listeners
-        notifyEvioListeners(event, parent);
-
-        return;
-    }
-
-
-    /**
-     * This is when a structure is encountered while parsing an event. It notifies all listeners about the structure.
-     *
-     * @param structure the structure encountered, which may be a Bank, Segment, or TagSegment.
-     */
-    protected void notifyEvioListeners(EvioEvent evioEvent, IEvioStructure structure) {
-
-        // are notifications turned off?
-        if (!notificationActive) {
-            return;
-        }
-
-        if (evioListenerList == null) {
-            return;
-        }
-
-        // if there is a global filter, lets use it.
-        if (evioFilter != null) {
-            if (!evioFilter.accept(structure.getStructureType(), structure.getHeader())) {
-                return;
-            }
-        }
-
-        // Guaranteed to return a non-null array
-        Object[] listeners = evioListenerList.getListenerList();
-
-        // This weird loop is the bullet proof way of notifying all listeners.
-        for (int i = listeners.length - 2; i >= 0; i -= 2) {
-            if (listeners[i] == IEvioListener.class) {
-                ((IEvioListener) listeners[i + 1]).gotStructure(evioEvent, structure);
-            }
-        }
-    }
-
-    /**
-     * Remove an Evio listener. Evio listeners listen for structures encountered when an event is being parsed.
-     *
-     * @param listener The Evio listener to remove.
-     */
-    public void removeEvioListener(IEvioListener listener) {
-
-        if ((listener == null) || (evioListenerList == null)) {
-            return;
-        }
-
-        evioListenerList.remove(IEvioListener.class, listener);
-    }
-
-    /**
-     * Add an Evio listener. Evio listeners listen for structures encountered when an event is being parsed.
-     *
-     * @param listener The Evio listener to add.
-     */
-    public void addEvioListener(IEvioListener listener) {
-
-        if (listener == null) {
-            return;
-        }
-
-        if (evioListenerList == null) {
-            evioListenerList = new EventListenerList();
-        }
-
-        evioListenerList.add(IEvioListener.class, listener);
-    }
-
-    /**
-     * Get the flag determining whether notification of listeners is active. Normally it is. But in some cases it should
-     * be temporarily suspended. For example, in a "goto event" process, the listeners will not be notified of the
-     * intervening events as the file is scanned to get to the target event.
-     *
-     * @return <code>true</code> if notification of events to the listeners is active.
-     */
-    public boolean isNotificationActive() {
-        return notificationActive;
-    }
-
-    /**
-     * Set the flag determining whether notification of listeners is active. Normally it is. But in some cases it
-     * should be temporarily suspended. For example, in a "goto event" process, the listeners will not be notified of
-     * the intervening events as the file is scanned to get to the target event.
-     *
-     * @param notificationActive set <code>true</code> if notification of events to the listeners is active.
-     */
-    public void setNotificationActive(boolean notificationActive) {
-        this.notificationActive = notificationActive;
-    }
-
-    /**
-     * Set the global filter used for filtering structures. If set to <code>null</code>, the default, then all
-     * structures will be sent to the listeners.
-     *
-     * @param evioFilter the filter to set.
-     * @see IEvioFilter
-     */
-    public void setEvioFilter(IEvioFilter evioFilter) {
-        this.evioFilter = evioFilter;
-    }
-
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N DataType.java
--- DataType.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,98 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This an enum used to convert data type numerical values to a more meaningful name. For example, the data type with
- * value 0xe corresponds to the enum BANK. Mostly this is used for printing.
- * 
- * @author heddle
- * 
- */
-public enum DataType {
-
-	UNKNOWN32      (0x0), 
-	UINT32         (0x1), 
-	FLOAT32        (0x2), 
-	CHARSTAR8      (0x3), 
-	SHORT16        (0x4), 
-	USHORT16       (0x5), 
-	CHAR8          (0x6), 
-	UCHAR8         (0x7), 
-	DOUBLE64       (0x8), 
-	LONG64         (0x9), 
-	ULONG64        (0xa), 
-	INT32          (0xb), 
-	TAGSEGMENT     (0xc), 
-	SEGMENT        (0xd), 
-	BANK           (0xe), 
-	ALSOBANK       (0x10), 
-	ALSOSEGMENT    (0x20), 
-	ALSOTAGSEGMENT (0x40);
-
-	private int value;
-
-	private DataType(int value) {
-		this.value = value;
-	}
-
-	/**
-	 * Get the enum's value.
-	 * 
-	 * @return the value, e.g., 0xe for a BANK
-	 */
-	public int getValue() {
-		return value;
-	}
-
-	/**
-	 * Obtain the name from the value.
-	 * 
-	 * @param value the value to match.
-	 * @return the name, or "UNKNOWN".
-	 */
-	public static String getName(int value) {
-		DataType datatypes[] = DataType.values();
-		for (DataType dt : datatypes) {
-			if (dt.value == value) {
-				return dt.name();
-			}
-		}
-		return "UNKNOWN";
-	}
-
-	/**
-	 * Obtain the enum from the value.
-     * 
-	 * 
-	 * @param value the value to match.
-	 * @return the matching enum, or <code>null</code>.
-	 */
-	public static DataType getDataType(int value) {
-		DataType datatypes[] = DataType.values();
-		for (DataType dt : datatypes) {
-			if (dt.value == value) {
-				return dt;
-			}
-		}
-		return null;
-	}
-	
-	/**
-	 * Convenience routine to see if "this" data type is a structure (a container.)
-	 * @return <code>true</code> if the data type corresponds to one of the structure
-	 * types: BANK, SEGMENT, or TAGSEGMENT.
-	 */
-	public boolean isStructure() {
-		switch (this) {
-		case BANK:
-		case SEGMENT:
-		case TAGSEGMENT:
-			return true;
-		case ALSOBANK:
-		case ALSOSEGMENT:
-		case ALSOTAGSEGMENT:
-			return true;
-		default:
-			return false;
-		}
-	}
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N Demo.java
--- Demo.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,127 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-
-/**
- * Used for demoing the JEvio library.
- * 
- * @author heddle
- * 
- */
-public class Demo implements IEvioListener {
-
-	/**
-	 * Main program for testing
-	 * 
-	 * @param args the command line arguments.
-	 */
-	public static void main(String args[]) {
-		System.out.println("Test of EvioFile class.");
-
-		String cwd = Environment.getInstance().getCurrentWorkingDirectory();
-
-		// assumes we have a directory "testdata" with the test files in the cwd.
-//		String testEventFile = cwd + "\\testdata\\dennis.ev";
-//		String testEventFile = cwd + "\\testdata\\out.ev";
-//		String testDictFile = cwd + "\\testdata\\eviodict.xml";
-        String testEventFile = cwd + File.separator + "testdata" + File.separator + "out.ev";
-        String testDictFile  = cwd + File.separator + "testdata" + File.separator + "eviodict.xml";
-
-		EvioFile evioFile = null;
-
-		try {
-			File file = new File(testEventFile);
-			System.out.println("ev file: " + testEventFile + " size: " + file.length());
-
-			evioFile = new EvioFile(testEventFile);
-			
-			// uncomment below to test a filter
-//			IEvioFilter myFilter = new IEvioFilter() {
-//				@Override
-//				public boolean accept(StructureType structureType, BaseStructureHeader structureHeader) {
-//					DataType dataType = structureHeader.getDataTypeEnum();
-//					
-//					return (dataType == DataType.DOUBLE64);
-//				}
-//			};
-//			EventParser.getInstance().setEvioFilter(myFilter);
-
-			
-			//add myself as a listener
-			EventParser.getInstance().addEvioListener(new Demo());
-
-			// create a dictionary, set the global name provider
-			NameProvider.setProvider(NameProviderFactory.createNameProvider(new File(testDictFile)));
-
-			// try a block test
-			EvioFileTest.readAllBlockHeadersTest(evioFile);
-
-			// try read all events test
-			EvioFileTest.readAllEventsTest(evioFile);
-
-			// just count the blocks
-			EvioFileTest.totalBlockCount(evioFile);
-
-			// try processing some events
-			EvioFileTest.parseEventsTest(evioFile, 1);
-		}
-		catch (FileNotFoundException e) {
-			e.printStackTrace();
-			System.exit(1);
-		}
-		catch (IOException e) {
-			e.printStackTrace();
-			System.exit(1);
-		}
-
-	}
-
-    public void startEventParse(EvioEvent evioEvent) { }
-
-    public void endEventParse(EvioEvent evioEvent) { }
-
-	/**
-	 * This IEvioListener has received a structure as the result of an event being parsed.
-	 * @param evioEvent the event being parsed.
-	 * @param structure the structure that I received. It is a BANK, SEGEMENT
-	 * or TAGSEGMENT.
-	 */
-	@Override
-	public void gotStructure(EvioEvent evioEvent, IEvioStructure structure) {
-
-		BaseStructureHeader header = structure.getHeader();
-
-		System.out.println("------------------");
-		System.out.println("" + structure);
-		
-		switch (header.getDataTypeEnum()) {
-		case DOUBLE64:
-			System.out.println("        DOUBLE VALS");
-			double doubledata[] = structure.getDoubleData();
-			for (double d : doubledata) {
-				System.out.println("         " + d);
-			}
-			break;
-			
-		case INT32: case UINT32:
-			System.out.println("        INT VALS");
-			int intdata[] = structure.getIntData();
-			for (int i : intdata) {
-				System.out.println("         " + i);
-			}
-			break;
-			
-		case CHAR8: case UCHAR8:
-			System.out.println("        BYTE VALS");
-			byte bytedata[] = structure.getByteData();
-			for (byte i : bytedata) {
-				System.out.println("         " + i);
-			}
-			break;
-		}
-
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N Environment.java
--- Environment.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,203 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-
-/**
- * This is a utility class employing a singleton to obtain environment information, such as user name, home directory,
- * OS name, etc.
- * 
- * @author heddle
- * 
- */
-public class Environment {
-
-	/**
-	 * Singleton instantiation.
-	 */
-	private static Environment environment;
-
-	/**
-	 * User's home directory.
-	 */
-
-	private String homeDirectory;
-
-	/**
-	 * Current working directory
-	 */
-
-	private String currentWorkingDirectory;
-
-	/**
-	 * User name
-	 */
-
-	private String userName;
-
-	/**
-	 * Operating System Name
-	 */
-
-	private String osName;
-
-	/**
-	 * Temporary Directory
-	 */
-
-	private String tempDirectory;
-
-	/**
-	 * Class path.
-	 */
-	private String classPath;
-
-	/**
-	 * The host name.
-	 */
-	private String hostName;
-
-	/**
-	 * Private constructor for the singleton.
-	 */
-	private Environment() {
-		homeDirectory = getProperty("user.home");
-		currentWorkingDirectory = getProperty("user.dir");
-		userName = getProperty("user.name");
-		osName = getProperty("os.name");
-		tempDirectory = getProperty("java.io.tmpdir");
-		classPath = getProperty("java.class.path");
-
-		try {
-			InetAddress addr = InetAddress.getLocalHost();
-
-			// Get hostname
-			hostName = addr.getHostName();
-		}
-		catch (UnknownHostException e) {
-			hostName = "???";
-		}
-
-	}
-
-	/**
-	 * Accessor for the singleton.
-	 * 
-	 * @return the singleton <code>Environment</code> object.
-	 */
-	public static Environment getInstance() {
-		if (environment == null) {
-			environment = new Environment();
-		}
-		return environment;
-	}
-
-	/**
-	 * Convenience routine for getting a system property.
-	 * 
-	 * @param keyName the key name of the property
-	 * @return the property, or <code>null</null>.
-	 */
-	private String getProperty(String keyName) {
-		try {
-			return System.getProperty(keyName);
-		}
-		catch (Exception e) {
-			return null;
-		}
-	}
-
-	/**
-	 * Get the current class path.
-	 * 
-	 * @return the current class path.
-	 */
-	public String getClassPath() {
-		return classPath;
-	}
-
-	/**
-	 * Get the current working directory.
-	 * 
-	 * @return the current WorkingDirectory.
-	 */
-	public String getCurrentWorkingDirectory() {
-		return currentWorkingDirectory;
-	}
-
-	/**
-	 * Get the user's home directory.
-	 * 
-	 * @return the home directory.
-	 */
-	public String getHomeDirectory() {
-		return homeDirectory;
-	}
-
-	/**
-	 * Get the operating system name.
-	 * 
-	 * @return the operating system name.
-	 */
-	public String getOsName() {
-		return osName;
-	}
-
-	/**
-	 * Get the temp directory.
-	 * 
-	 * @return the temp directory.
-	 */
-	public String getTempDirectory() {
-		return tempDirectory;
-	}
-
-	/**
-	 * Get the user name.
-	 * 
-	 * @return the userName.
-	 */
-	public String getUserName() {
-		return userName;
-	}
-
-	/**
-	 * Get the host name.
-	 * 
-	 * @return the host name.
-	 */
-	public String getHostName() {
-		return hostName;
-	}
-
-	/**
-	 * Convert to a string for diagnostics
-	 * 
-	 * @return The string
-	 */
-
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(1024);
-		sb.append("Environment: \n");
-		sb.append("Host Name: " + getHostName() + "\n");
-		sb.append("User Name: " + getUserName() + "\n");
-		sb.append("Temp Directory: " + getTempDirectory() + "\n");
-		sb.append("OS Name: " + getOsName() + "\n");
-		sb.append("Home Directory: " + getHomeDirectory() + "\n");
-		sb.append("Current Working Directory: " + getCurrentWorkingDirectory() + "\n");
-		sb.append("Class Path: " + getClassPath() + "\n");
-		return sb.toString();
-	}
-
-	/**
-	 * Main program used for testing only.
-	 * 
-	 * @param args
-	 */
-	public static void main(String[] args) {
-		Environment env = Environment.getInstance();
-		System.out.println(env.toString());
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EventBuilder.java
--- EventBuilder.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,442 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.io.File;
-
-/**
- * This class is used for creating and manipulating events. One constructor is convenient for creating new events while
- * another is useful for manipulating existing events. You can create a new EventBuilder for each event being handled,
- * However, in many cases one can use the same EventBuilder for all events by calling the setEvent method.
- * The only reason a singleton pattern was not used was to allow for the possibility that events will be built or
- * manipulated on multiple threads.
- * @author heddle
- *
- */
-public class EventBuilder {
-
-	/**
-	 * The event being built
-	 */
-	private EvioEvent event;
-	
-	
-	/**
-	 * This is the constructor to use for an EventBuilder object that will operate on a new, empty event.
-	 * @param tag the tag for the event header (which is just a bank header).
-	 * @param dataType the data type for the event object--which again is just the type for the outer most
-	 * bank. Often an event is a bank of banks, so typically this will be DataType.BANK, or 0xe (14).
-	 * @param num often an ordinal enumeration.
-	 */
-	public EventBuilder(int tag, DataType dataType, int num) {
-		//create an event with the correct header data. 
-		event = new EvioEvent(tag, dataType, num);
-	}
-	
-	/**
-	 * This is the constructor to use when you want to manipulate an existing event.
-	 * @param event the event to manipulate.
-	 */
-	public EventBuilder(EvioEvent event) {
-		this.event = event;
-	}
-	
-	/**
-	 * This goes through the event recursively, and makes sure all the length fields
-	 * in the headers are properly set.
-	 */
-	public void setAllHeaderLengths() {
-		event.setAllHeaderLengths();
-	}
-		
-	/**
-	 * This clears all the data fields in a structure, but not the parent or the children. This keeps the
-	 * existing tree structure intact. To remove a structure (and, consequently, all its descendants) from the
-	 * tree, use <code>remove</code>
-	 * @param structure the segment to clear.
-	 */
-	public void clearData(BaseStructure structure) {
-		if (structure != null) {
-			structure.rawBytes = null;
-			structure.doubleData = null;
-			structure.floatData = null;
-			structure.intData = null;
-			structure.longData = null;
-			structure.shortData = null;
-		}
-	}
-	
-	/**
-	 * Add a child to a parent structure.
-     *
-	 * @param parent the parent structure.
-	 * @param child the child structure.
-	 * @throws EvioException if child is null, has wrong byte order,
-     *                       is wrong structure type, or parent is not a container
-	 */
-	public void addChild(BaseStructure parent, BaseStructure child) throws EvioException {
-		
-		if (child == null) {
-			throw new EvioException("Attempt to add null child in addChild.");
-		}
-
-        if (child.getByteOrder() != event.getByteOrder()) {
-            throw new EvioException("Attempt to add child with opposite byte order.");
-        }
-		
-		// the child must be consistent with the data type of the parent. For example, if the child
-		//is a BANK, then the data type of the parent but be BANK.
-		DataType parentDataType = parent.header.getDataTypeEnum();
-		String errStr;
-		if (parentDataType.isStructure()) {
-			switch(parentDataType) {
-			case BANK: case ALSOBANK:
-				if (child.getStructureType() != StructureType.BANK) {
-					errStr = "Type mismatch in addChild. Parent content type: " + parentDataType + 
-					" child type: " + child.getStructureType();
-					throw new EvioException(errStr);
-				}
-				break;
-				
-			case SEGMENT: case ALSOSEGMENT:
-				if (child.getStructureType() != StructureType.SEGMENT) {
-					errStr = "Type mismatch in addChild. Parent content type: " + parentDataType + 
-					" child type: " + child.getStructureType();
-					throw new EvioException(errStr);
-				}
-				break;
-				
-			case TAGSEGMENT: case ALSOTAGSEGMENT:
-				if (child.getStructureType() != StructureType.TAGSEGMENT) {
-					errStr = "Type mismatch in addChild. Parent content type: " + parentDataType + 
-					" child type: " + child.getStructureType();
-					throw new EvioException(errStr);
-				}
-				break;
-			}
-		}
-		else { //parent is not a container--it is expecting to hold primitives and cannot have children
-			errStr = "Type mismatch in addChild. Parent content type: " + parentDataType + 
-			" cannot have children.";
-			throw new EvioException(errStr);
-		}
-		
-
-		parent.insert(child);
-		setAllHeaderLengths();
-	}
-	
-	/**
-	 * This removes a structure (and all its descendants) from the tree.
-	 * @param child the child structure to remove.
-	 * @throws EvioException
-	 */
-	public void remove(BaseStructure child) throws EvioException {
-		if (child == null) {
-			throw new EvioException("Attempt to remove null child.");
-		}
-		
-		BaseStructure parent = child.getParent(); 
-		
-		//the only orphan structure is the event itself, which cannot be removed.
-		if (parent == null) {
-			throw new EvioException("Attempt to remove root node, i.e., the event. Don't remove an event. Just discard it.");
-		}
-				
-		child.removeFromParent();
-		setAllHeaderLengths();
-	}
-	
-	/**
-	 * Appends int data to the structure. If the structure has no data, then this
-	 * is the same as setting the data.
-	 * @param structure the structure to receive the data, which is appended.
-	 * @param data the int data to append, or set if there is no existing data.
-	 * @throws EvioException
-	 */
-	public void appendIntData(BaseStructure structure, int data[]) throws EvioException {
-		if (structure == null) {
-			throw new EvioException("Tried to append int data to a null structure.");
-		}
-		structure.appendIntData(data);
-		setAllHeaderLengths();
-	}
-	
-	/**
-	 * Appends short data to the structure. If the structure has no data, then this
-	 * is the same as setting the data.
-	 * @param structure the structure to receive the data, which is appended.
-	 * @param data the short data to append, or set if there is no existing data.
-	 * @throws EvioException
-	 */
-	public void appendShortData(BaseStructure structure, short data[]) throws EvioException {
-		if (structure == null) {
-			throw new EvioException("Tried to append short data to a null structure.");
-		}
-		structure.appendShortData(data);
-		setAllHeaderLengths();
-	}
-
-	
-	/**
-	 * Appends long data to the structure. If the structure has no data, then this
-	 * is the same as setting the data.
-	 * @param structure the structure to receive the data, which is appended.
-	 * @param data the long data to append, or set if there is no existing data.
-	 * @throws EvioException
-	 */
-	public void appendLongData(BaseStructure structure, long data[]) throws EvioException {
-		if (structure == null) {
-			throw new EvioException("Tried to append long data to a null structure.");
-		}
-		structure.appendLongData(data);
-		setAllHeaderLengths();
-	}
-	
-	/**
-	 * Appends byte data to the structure. If the structure has no data, then this
-	 * is the same as setting the data.
-	 * @param structure the structure to receive the data, which is appended.
-	 * @param data the byte data to append, or set if there is no existing data.
-	 * @throws EvioException
-	 */
-	public void appendByteData(BaseStructure structure, byte data[]) throws EvioException {
-		if (structure == null) {
-			throw new EvioException("Tried to append byte data to a null structure.");
-		}
-		structure.appendByteData(data);
-		setAllHeaderLengths();
-	}
-	
-	/**
-	 * Appends float data to the structure. If the structure has no data, then this
-	 * is the same as setting the data.
-	 * @param structure the structure to receive the data, which is appended.
-	 * @param data the float data to append, or set if there is no existing data.
-	 * @throws EvioException
-	 */
-	public void appendFloatData(BaseStructure structure, float data[]) throws EvioException {
-		if (structure == null) {
-			throw new EvioException("Tried to append float data to a null structure.");
-		}
-		structure.appendFloatData(data);
-		setAllHeaderLengths();
-	}
-	
-//    /**
-//     * Appends char data to the structure. If the structure has no data, then this
-//     * is the same as setting the data.
-//     * @param structure the structure to receive the data, which is appended.
-//     * @param data the char data to append, or set if there is no existing data.
-//     * @throws EvioException
-//     */
-//    public void appendCharData(BaseStructure structure, char data[]) throws EvioException {
-//
-//        if (structure == null) {
-//            throw new EvioException("Tried to append char data to a null structure.");
-//        }
-//        structure.appendCharData(data);
-//        setAllHeaderLengths();
-//    }
-
-    /**
-     * Appends string data to the structure. If the structure has no data, then this
-     * is the same as setting the data.
-     * @param structure the structure to receive the data, which is appended.
-     * @param data the string to append, or set if there is no existing data.
-     * @throws EvioException
-     */
-    public void appendStringData(BaseStructure structure, String data) throws EvioException {
-
-        if (structure == null) {
-            throw new EvioException("Tried to append String to a null structure.");
-        }
-        structure.appendStringData(data);
-        setAllHeaderLengths();
-    }
-
-
-	/**
-	 * Appends double data to the structure. If the structure has no data, then this
-	 * is the same as setting the data.
-	 * @param structure the structure to receive the data, which is appended.
-	 * @param data the double data to append, or set if there is no existing data.
-	 * @throws EvioException
-	 */
-	public void appendDoubleData(BaseStructure structure, double data[]) throws EvioException {
-		if (structure == null) {
-			throw new EvioException("Tried to append double data to a null structure.");
-		}
-		structure.appendDoubleData(data);
-	}
-	
-	/**
-	 * Get the underlying event.
-	 * @return the underlying event.
-	 */
-	public EvioEvent getEvent() {
-		return event;
-	}
-	
-	/**
-	 * Set the underlying event. As far as this event builder is concerned, the
-	 * previous underlying event is lost, and all subsequent calls will affect
-	 * the newly supplied event.
-	 * param the new underlying event.
-	 */
-	public void setEvent(EvioEvent event) {
-		this.event = event;
-	}
-	
-	/**
-	 * Main program for testing.
-	 * @param args ignored command line arguments.
-	 */
-	public static void main(String args[]) {
-		//create an event writer to write out the test events.
-		String outfile = "C:\\Documents and Settings\\heddle\\My Documents\\test.ev";
-		EventWriter eventWriter = null;
-		try {
-			eventWriter = new EventWriter(new File(outfile));
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-			System.exit(1);
-		}
-		
-		//count the events we make for testing
-		int eventNumber = 1;
-		
-		//use a tag of 11 for events--for no particular reason
-		int tag = 11;
-		
-		try {
-			//first event-- a trivial event containing an array of ints. 
-			EventBuilder eventBuilder = new EventBuilder(tag, DataType.INT32, eventNumber++);
-			EvioEvent event1 = eventBuilder.getEvent();
-			//should end up with int array 1..25,1..10
-			eventBuilder.appendIntData(event1, fakeIntArray(25));
-			eventBuilder.appendIntData(event1, fakeIntArray(10));
-			eventWriter.writeEvent(event1);
-			
-			//second event, more traditional bank of banks
-			eventBuilder = new EventBuilder(tag, DataType.BANK, eventNumber++);
-			EvioEvent event2 = eventBuilder.getEvent();
-			
-			//add a bank of doubles
-			EvioBank bank1 = new EvioBank(22, DataType.DOUBLE64, 0);
-			eventBuilder.appendDoubleData(bank1, fakeDoubleArray(10));
-			eventBuilder.addChild(event2, bank1);
-			eventWriter.writeEvent(event2);
-			
-			//lets modify event2
-			event2.getHeader().setNumber(eventNumber++);
-			EvioBank bank2 = new EvioBank(33, DataType.BANK, 0);
-			eventBuilder.addChild(event2, bank2);
-
-			EvioBank subBank1 = new EvioBank(34, DataType.SHORT16, 1);
-			eventBuilder.addChild(bank2, subBank1);
-			eventBuilder.appendShortData(subBank1, fakeShortArray(5));
-			
-						
-			
-			//now add a bank of segments
-			EvioBank subBank2 = new EvioBank(33, DataType.SEGMENT, 0);
-			eventBuilder.addChild(bank2, subBank2);
-			
-			EvioSegment segment1 = new EvioSegment(34, DataType.SHORT16);
-			eventBuilder.addChild(subBank2, segment1);
-			eventBuilder.appendShortData(segment1, fakeShortArray(7));
-			
-			EvioSegment segment2 = new EvioSegment(34, DataType.SHORT16);
-			eventBuilder.addChild(subBank2, segment2);
-			eventBuilder.appendShortData(segment2, fakeShortArray(10));
-			
-			
-			//now add a bank of tag segments
-			EvioBank subBank3 = new EvioBank(45, DataType.TAGSEGMENT, 0);
-			eventBuilder.addChild(bank2, subBank3);
-
-			EvioTagSegment tagsegment1 = new EvioTagSegment(34, DataType.INT32);
-			eventBuilder.addChild(subBank3, tagsegment1);
-			eventBuilder.appendIntData(tagsegment1, fakeIntArray(3));
-			
-			EvioTagSegment tagsegment2 = new EvioTagSegment(34, DataType.CHARSTAR8);
-			eventBuilder.addChild(subBank3, tagsegment2);
-			eventBuilder.appendStringData(tagsegment2, "This is a string");
-
-			
-//			System.err.println("EVENT2: " + event2.getHeader());
-//			System.err.println("BANK1: " + bank1.getHeader());
-//			System.err.println("BANK2: " + bank2.getHeader());
-//			System.err.println("SUBBANK1: " + subBank1.getHeader());
-//			System.err.println("SUBBANK2: " + subBank2.getHeader());
-//			System.err.println("segment1: " + segment1.getHeader());
-//			System.err.println("segment2: " + segment2.getHeader());
-//			System.err.println("SUBBANK3: " + subBank3.getHeader());
-//			System.err.println("tagseg1: " + tagsegment1.getHeader());
-			
-			
-			//write the event
-			eventWriter.writeEvent(event2);		
-			
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-		}
-
-		//all done 
-		eventWriter.close();
-		
-		System.out.println("Test completed.");
-	}
-	
-	/**
-	 * Array of ints, sequential, 1..size, for test purposes.
-	 * @param size the size of the array.
-	 * @return the fake int array.
-	 */
-	private static int[] fakeIntArray(int size) {
-		int[] array = new int[size];
-		for (int i = 0; i < size; i++) {
-			array[i] = i+1;
-		}
-		return array;
-	}
-	
-	/**
-	 * Array of shorts, sequential, 1..size, for test purposes.
-	 * @param size the size of the array.
-	 * @return the fake short array.
-	 */
-	private static short[] fakeShortArray(int size) {
-		short[] array = new short[size];
-		for (int i = 0; i < size; i++) {
-			array[i] = (short)(i+1);
-		}
-		return array;
-	}
-	
-	/**
-	 * Array of characters for test purposes.
-	 * @return the fake char array.
-	 */
-	private static char[] fakeCharArray() {
-		char array[] = {'T','h','i','s',' ','i','s',' ','c','h','a','r',' ', 'd','a','t','a','.'};
-		return array;
-	}
-
-
-	
-	/**
-	 * Array of doubles, sequential, 1..size, for test purposes.
-	 * @param size the size of the array.
-	 * @return the fake double array.
-	 */
-	private static double[] fakeDoubleArray(int size) {
-		double[] array = new double[size];
-		for (int i = 0; i < size; i++) {
-			array[i] = i+1;
-		}
-		return array;
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EventParser.java
--- EventParser.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,445 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-import javax.swing.event.EventListenerList;
-import javax.swing.tree.DefaultTreeModel;
-
-/**
- * Uses the singleton pattern to create an object that controls the parsing of events.
- * This object, like the EvioFile object, has a method for parsing an event. An EvioFile
- * object will ultimately call this method--i.e., the concrete implementation of event
- * parsing is in this class.
- * 
- * @author heddle
- * 
- */
-public class EventParser {
-
-	/**
-	 * Listener list for structures (banks, segments, tagsegments) encountered while processing an event.
-	 */
-	private EventListenerList evioListenerList;
-
-	/**
-	 * This flag determines whether notification of listeners is active. Normally it is. But in some cases it should be
-	 * temporarily suspended. For example, in a "goto event" process, the listeners will not be notified of the
-	 * intervening events as the file is scanned to get to the target event.
-	 */
-	protected boolean notificationActive = true;
-
-	/**
-	 * Singleton parser.
-	 */
-	private static EventParser parser = new EventParser();
-
-	/**
-	 * Returns the singleton <code>EventParser</code> object.
-	 * 
-	 * @return the singleton event parser.
-	 */
-	public static EventParser getInstance() {
-		return parser;
-	}
-
-	/**
-	 * A single global structure filter. This may prove to be a limitation: perhaps we want one per listener.
-	 */
-	private IEvioFilter evioFilter;
-
-	/**
-	 * This is the workhorse method for parsing the event. It will drill down and uncover all structures
-     * (banks, segments, and tagsegments) and notify any interested listeners in a SAX-Like manner. <br>
-	 * Note: applications may choose not to provide a listener. In that case, when the event is parsed, its structures
-	 * may be accessed through the event's tree model, i.e., via <code>event.getTreeModel()</code>.
-	 * 
-	 * @param evioEvent the event to parse.
-	 * @throws EvioException
-	 */
-	public synchronized void parseEvent(EvioEvent evioEvent) throws EvioException {
-
-		if (evioEvent == null) {
-			throw new EvioException("Null event in parseEvent.");
-		}
-
-        //let listeners know we started
-        notifyStart(evioEvent);
-
-		// The event itself is a stucture (EvioEvent extends EvioBank) so just
-		// parse it as such. The recursive drill down will take care of the rest.
-		parseStructure(evioEvent, evioEvent);
-
-        //let listeners know we stopped
-        notifyStop(evioEvent);        
-	}
-
-	/**
-	 * Parse a structure. If it is a structure of structures, such as a bank of banks or a segment of tag segments,
-	 * parse recursively. Listeners are notified AFTER all their children have been handled, not before. Thus the
-	 * LAST structure that will send notification is the outermost bank--the event bank itself.
-	 * 
-	 * @param evioEvent the parent event being processed.
-	 * @param structure the structure being processed.
-	 * @throws EvioException
-	 */
-	private void parseStructure(EvioEvent evioEvent, BaseStructure structure) throws EvioException {
-
-		// update the tree
-		BaseStructure child = structure;
-		BaseStructure parent = child.getParent();
-
-		if (parent == null) { // start of event
-			evioEvent.treeModel = new DefaultTreeModel(evioEvent);
-		}
-		else {
-			evioEvent.insert(child, parent);
-		}
-
-		// if it is not a structure of structures, we are done. That will leave the raw bytes in
-		// the "leaf" structures (e.g., a bank of ints) --which will be interpreted by the various get data methods.
-		DataType dataType = structure.getHeader().getDataTypeEnum();        
-		if (!dataType.isStructure()) {
-			// notify the listeners
-			notifyEvioListeners(evioEvent, structure);
-			return;
-		}
-
-		// Does the present structure contain structures? (as opposed to a leaf, which contains primitives). If
-		// it is a leaf we are done. That will leave the raw bytes in the "leaf" structures (e.g., a bank of ints)
-		// --which will be interpreted by the various "get data" methods.
-		if (dataType.isStructure()) { //NOT a leaf
-			byte bytes[] = structure.getRawBytes();
-            ByteOrder byteOrder = structure.getByteOrder();
-
-			if (bytes == null) {
-				if (evioEvent == null) {
-					throw new EvioException("Null data in parseStructure (Bank).");
-				}
-			}
-
-			int length = bytes.length;
-			int offset = 0;
-
-			switch (dataType) {
-			case BANK:
-			case ALSOBANK:
-
-				// extract all the banks from this bank.
-				while (offset < length) {
-					BankHeader header = createBankHeader(bytes, offset, byteOrder);
-
-					// offset still points to beginning of new header. Have to get data for new child bank.
-					int newByteLen = 4 * (header.getLength() - 1); // -1 to account for extra header word
-					byte newBytes[] = new byte[newByteLen];
-					System.arraycopy(bytes, offset + 8, newBytes, 0, newByteLen);
-
-					// we can now create a new bank
-					EvioBank childBank = new EvioBank(header);
-					childBank.setParent(structure);
-
-					childBank.setRawBytes(newBytes);
-                    childBank.setByteOrder(byteOrder);
-					parseStructure(evioEvent, childBank);
-
-					// position offset to start of next header
-					offset += 4 * (header.getLength() + 1); // plus 1 for length word
-				}
-				break; // structure contains banks
-
-			case SEGMENT:
-			case ALSOSEGMENT:
-
-				// extract all the segments from this bank.
-				while (offset < length) {
-					SegmentHeader header = createSegmentHeader(bytes, offset, byteOrder);
-
-					// offset still points to beginning of new header. Have to get data for new child segment.
-					int newByteLen = 4 * header.getLength();
-					byte newBytes[] = new byte[newByteLen];
-					System.arraycopy(bytes, offset + 4, newBytes, 0, newByteLen);
-
-					// we can now create a new segment
-					EvioSegment childSegment = new EvioSegment(header);
-					childSegment.setParent(structure);
-
-					childSegment.setRawBytes(newBytes);
-                    childSegment.setByteOrder(byteOrder);
-					parseStructure(evioEvent, childSegment);
-
-					// position offset to start of next header
-					offset += 4 * (header.getLength() + 1); // plus 1 for length word
-				}
-
-				break; // structure contains segments
-
-			case TAGSEGMENT:
-			case ALSOTAGSEGMENT:
-
-				// extract all the tag segments from this bank.
-				while (offset < length) {
-					TagSegmentHeader header = createTagSegmentHeader(bytes, offset, byteOrder);
-
-					// offset still points to beginning of new header. Have to get data for new child tag segment.
-					int newByteLen = 4 * header.getLength();
-					byte newBytes[] = new byte[newByteLen];
-					System.arraycopy(bytes, offset + 4, newBytes, 0, newByteLen);
-
-					// we can now create a new tag segment
-					EvioTagSegment childTagSegment = new EvioTagSegment(header);
-					childTagSegment.setParent(structure);
-
-					childTagSegment.setRawBytes(newBytes);
-                    childTagSegment.setByteOrder(byteOrder);
-					parseStructure(evioEvent, childTagSegment);
-
-					// position offset to start of next header
-					offset += 4 * (header.getLength() + 1); // plus 1 for length word
-				}
-
-				break;
-			}
-		} //end not a leaf
-		// notify the listeners
-		notifyEvioListeners(evioEvent, structure);
-	} // parseStructure
-
-	/**
-	 * Create a bank header from the first eight bytes of the data array.
-	 * 
-	 * @param bytes the byte array, probably from a bank that encloses this new bank.
-	 * @param offset the offset to start reading from the byte array.
-     * @param byteOrder byte order of array, {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}
-	 * @return the new header.
-	 */
-	private BankHeader createBankHeader(byte bytes[], int offset, ByteOrder byteOrder) {
-		BankHeader header = new BankHeader();
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		byteBuffer.position(offset);
-
-		header.setLength(byteBuffer.getInt());
-
-		if (byteOrder == ByteOrder.BIG_ENDIAN) {
-            // interested in bit pattern, not negative numbers
-            header.setTag(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setNumber(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-		}
-		else {
-            header.setNumber(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setTag(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-		}
-		return header;
-	}
-
-	/**
-	 * Create a segment header from the first four bytes of the data array.
-	 * 
-	 * @param bytes the byte array, probably from a bank that encloses this new segment.
-	 * @param offset the offset to start reading from the byte array.
-     * @param byteOrder byte order of array, {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}
-	 * @return the new header.
-	 */
-	private SegmentHeader createSegmentHeader(byte bytes[], int offset, ByteOrder byteOrder) {
-		SegmentHeader header = new SegmentHeader();
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		byteBuffer.position(offset);
-
-		if (byteOrder == ByteOrder.BIG_ENDIAN) {
-            header.setTag(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-		}
-		else {
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-            header.setTag(ByteDataTransformer.byteBitsToInt(byteBuffer.get()));
-		}
-
-		return header;
-	}
-
-	/**
-	 * Create a tag segment header from the first four bytes of the data array.
-	 * 
-	 * @param bytes the byte array, probably from a bank that encloses this new tag segment.
-	 * @param offset the offset to start reading from the byte array.
-     * @param byteOrder byte order of array, {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}
-	 * @return the new header.
-	 */
-	private TagSegmentHeader createTagSegmentHeader(byte bytes[], int offset, ByteOrder byteOrder) {
-		TagSegmentHeader header = new TagSegmentHeader();
-		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes).order(byteOrder);
-		byteBuffer.position(offset);
-
-		int temp;
-
-		if (byteOrder == ByteOrder.BIG_ENDIAN) {
-            temp = ByteDataTransformer.shortBitsToInt(byteBuffer.getShort());
-            header.setTag(temp >>> 4);
-            header.setDataType(temp & 0xF);
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-		}
-		else {
-            header.setLength(ByteDataTransformer.shortBitsToInt(byteBuffer.getShort()));
-            temp = ByteDataTransformer.shortBitsToInt(byteBuffer.getShort());
-            header.setTag(temp >>> 4);
-            header.setDataType(temp & 0xF);
-		}
-
-		return header;
-	}
-
-	/**
-	 * This is when a structure is encountered while parsing an event. It notifies all listeners about the structure.
-	 * 
-	 * @param structure the structure encountered, which may be a Bank, Segment, or TagSegment.
-	 */
-	protected void notifyEvioListeners(EvioEvent evioEvent, IEvioStructure structure) {
-
-		// are notifications turned off?
-		if (!notificationActive) {
-			return;
-		}
-
-		if (evioListenerList == null) {
-			return;
-		}
-
-		// if there is a global filter, lets use it.
-		if (evioFilter != null) {
-			if (!evioFilter.accept(structure.getStructureType(), structure.getHeader())) {
-				return;
-			}
-		}
-
-		// Guaranteed to return a non-null array
-		Object[] listeners = evioListenerList.getListenerList();
-
-		// This weird loop is the bullet proof way of notifying all listeners.
-		for (int i = listeners.length - 2; i >= 0; i -= 2) {
-			if (listeners[i] == IEvioListener.class) {
-				((IEvioListener) listeners[i + 1]).gotStructure(evioEvent, structure);
-			}
-		}
-	}
-
-    /**
-     * Notify listeners we are starting to parse a new event
-     * @param evioEvent the event in question;
-     */
-    protected void notifyStart(EvioEvent evioEvent) {
-
-        // are notifications turned off?
-        if (!notificationActive) {
-            return;
-        }
-
-        if (evioListenerList == null) {
-            return;
-        }
-
-        // Guaranteed to return a non-null array
-        Object[] listeners = evioListenerList.getListenerList();
-
-        // This weird loop is the bullet proof way of notifying all listeners.
-        for (int i = listeners.length - 2; i >= 0; i -= 2) {
-            if (listeners[i] == IEvioListener.class) {
-                ((IEvioListener) listeners[i + 1]).startEventParse(evioEvent);
-            }
-        }
-    }
-   
-    /**
-     * Notify listeners we are done to parsing a new event
-     * @param evioEvent the event in question;
-     */
-    protected void notifyStop(EvioEvent evioEvent) {
-
-        // are notifications turned off?
-        if (!notificationActive) {
-            return;
-        }
-
-        if (evioListenerList == null) {
-            return;
-        }
-
-        // Guaranteed to return a non-null array
-        Object[] listeners = evioListenerList.getListenerList();
-
-        // This weird loop is the bullet proof way of notifying all listeners.
-        for (int i = listeners.length - 2; i >= 0; i -= 2) {
-            if (listeners[i] == IEvioListener.class) {
-                ((IEvioListener) listeners[i + 1]).endEventParse(evioEvent);
-            }
-        }
-    }
-
-	/**
-	 * Remove an Evio listener. Evio listeners listen for structures encountered when an event is being parsed.
-	 * 
-	 * @param listener The Evio listener to remove.
-	 */
-	public void removeEvioListener(IEvioListener listener) {
-
-		if ((listener == null) || (evioListenerList == null)) {
-			return;
-		}
-
-		evioListenerList.remove(IEvioListener.class, listener);
-	}
-
-	/**
-	 * Add an Evio listener. Evio listeners listen for structures encountered when an event is being parsed.
-	 * 
-	 * @param listener The Evio listener to add.
-	 */
-	public void addEvioListener(IEvioListener listener) {
-
-		if (listener == null) {
-			return;
-		}
-
-		if (evioListenerList == null) {
-			evioListenerList = new EventListenerList();
-		}
-
-		evioListenerList.add(IEvioListener.class, listener);
-	}
-
-	/**
-	 * Get the flag determining whether notification of listeners is active. Normally it is. But in some cases it should
-	 * be temporarily suspended. For example, in a "goto event" process, the listeners will not be notified of the
-	 * intervening events as the file is scanned to get to the target event.
-	 * 
-	 * @return <code>true</code> if notification of events to the listeners is active.
-	 */
-	public boolean isNotificationActive() {
-		return notificationActive;
-	}
-
-	/**
-	 * Set the flag determining whether notification of listeners is active. Normally it is. But in some cases it
-	 * should be temporarily suspended. For example, in a "goto event" process, the listeners will not be notified of
-	 * the intervening events as the file is scanned to get to the target event.
-	 * 
-	 * @param notificationActive set <code>true</code> if notification of events to the listeners is active.
-	 */
-	public void setNotificationActive(boolean notificationActive) {
-		this.notificationActive = notificationActive;
-	}
-
-	/**
-	 * Set the global filter used for filtering structures. If set to <code>null</code>, the default, then all
-	 * structures will be sent to the listeners.
-	 * 
-	 * @param evioFilter the filter to set.
-	 * @see IEvioFilter
-	 */
-	public void setEvioFilter(IEvioFilter evioFilter) {
-		this.evioFilter = evioFilter;
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EventWriter.java
--- EventWriter.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,368 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.io.DataOutputStream;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-/**
- * An EventWriter object is used for writing events to a file in evio versions 2 and 3.
- * @author heddle
- *
- */
-public class EventWriter {
-	
-    /**
-     * Offset to where the block length is written in the byte buffer, which always has a physical
-     * record header at the top.
-     */
-    private static int BLOCK_LENGTH_OFFSET = 0;
-
-    /**
-     * Offset to where the header length is written in the byte buffer, which always has a physical
-     * record header at the top.
-     */
-    private static int HEADER_LENGTH_OFFSET = 8;
-
-	/**
-	 * Offset to where the start is written in the byte buffer, which always has a physical
-	 * record header at the top. The start is the offset to the start of the first event that
-	 * starts in a block.
-	 */
-	private static int START_OFFSET = 12;
-
-    /**
-     * Offset to where the end is written in the byte buffer, which always has a physical
-     * record header at the top. The end is the number of valid words (header + data) and will
-     * be the same as the blocksize for all blocks but the last.
-     */
-    private static int END_OFFSET = 16;
-
-    /**
-     * Offset to where the version number is written in the byte buffer, which always has a physical
-     * record header at the top.
-     */
-    private static int VERSION_OFFSET = 20;
-
-    /**
-     * Offset to where reserved 1 is written in the byte buffer, which always has a physical
-     * record header at the top.
-     */
-    private static int RESERVED1_OFFSET = 24;
-
-	/**
-	 * The default size used for writing a file, in ints. Max allowed: 32768. Must be a multiple of 256.
-	 */
-	private static int DEFAULT_BLOCK_SIZE = 8192;
-	
-	/**
-	 * The output stream used for writing a file
-	 */
-	private DataOutputStream dataOutputStream;
-	
-	/**
-	 * Block size for anachronistic physical record (block headers). A typical number is 8192.
-     * Must be a multiple of 256 with a max value of 32768.
-	 */
-	private int blockSize;
-	
-	/**
-	 * This is an internal byte buffer corresponding to one block (physical record). When this gets full it
-     * will be flushed to the external output stream (<code>dataOutputStream</code>) that represents the file.
-	 */
-	private ByteBuffer blockBuffer;
-	
-	/**
-	 * Checks for first event started in current buffer.
-	 */
-	private boolean updatedStart;
-	
-    /**
-     * Running count of the block number.
-     */
-    private int blockNumber = 0;
-    
-    /**
-     * We are going to use reserved1 in the block header to hold the ordinal count
-     * of the last event completed in the current block.<br>
-     */
-    private int lastEventWritten = 0;
-
-
-    /**
-     * Creates an event writer for writing to a file.
-     * @param file the file to write to. Will be created.<br>
-     * WARNING: If the file already exists, an attempt will be made to delete it. Appending
-     * to an existing event file is not supported.
-     * @throws EvioException
-      */
-    public EventWriter(File file) throws EvioException {
-        this(file, DEFAULT_BLOCK_SIZE);
-    }
-
-    /**
-     * Creates an event writer for writing to a file.
-     * @param filename name of the file to write to. Will be created.<br>
-     * WARNING: If the file already exists, an attempt will be made to delete it. Appending
-     * to an existing event file is not supported.
-     * @throws EvioException
-      */
-    public EventWriter(String filename) throws EvioException {
-        this(new File(filename), DEFAULT_BLOCK_SIZE);
-    }
-
-    /**
-     * Create an <code>EventWriter</code> for writing events to a file.
-     * @param file the file to write to. Will be created.<br> 
-     * WARNING: If the file already exists, an attempt will be made to delete it. Appending
-     * to an existing event file is not supported.
-     * @param blockSize the blocksize to use. A typical number is 8192. Must be a multiple of 256 with a
-     * max value of 32768.
-     * @throws EvioException
-     */
-    public EventWriter(File file, int blockSize) throws EvioException {
-    	this.blockSize = blockSize;
-    	
-		try {
-			dataOutputStream = new DataOutputStream(new FileOutputStream(file));
-		}
-		catch (FileNotFoundException e) {
-			throw new EvioException(e.getMessage());
-		}
-    }
-    
-    /**
-     * Create an <code>EventWriter</code> for writing events to a file.
-     * @param file the file to write to. Will be created.<br> 
-     * WARNING: If the file already exists, an attempt will be made to delete it. Appending
-     * to an existing event file is not supported.
-     * @param blockSize the blocksize to use. A typical number is 8192. Must be a multiple of 256 with a
-     * max value of 32768.
-     * @param okToDelete if <code>true</code> and the file already exists, an attempt will be made to delete the existing file.
-     * Appending to an existing event file is not supported at this time.
-     */
-    public EventWriter(File file, int blockSize, boolean okToDelete) throws EvioException {
-    	this.blockSize = blockSize;
-    	
-    	if (file == null) {
-    		throw new EvioException("Null file in EventWriter constructor");
-    	}
-    	
-    	// handle existing file
-    	if (file.exists() && file.isFile()) {
-    		if (okToDelete) {
-    			boolean deleted = file.delete();
-    			if (!deleted) {
-            		throw new EvioException("File in EventWriter constructor already exists, and could not be deleted. \n" +
-            				"File: " + file.getPath());
-    			}
-    		}
-    		else { // user requested no delete
-        		throw new EvioException("File in EventWriter constructor already exists, and user requested no deletion. \n" +
-        				"File: " + file.getPath());
-    		}
-    	}
-    	
-    	
-		try {
-			dataOutputStream = new DataOutputStream(new FileOutputStream(file));
-		}
-		catch (FileNotFoundException e) {
-    		throw new EvioException("Fow whatever reason, the file could not be opened. \n " + 
-    				"It could mean there is no permission to open the file for writing \n" +
-    				"or that the file was a directory." +
-    				"File: " + file.getPath());
-		}
-    }
-    
-    
-    /**
-     * Get a clean buffer. This is called at the start and also after every physical record
-     * is flushed to the file.
-     */
-    private void getCleanBuffer() {
-    	if (blockBuffer == null) {
-    		blockBuffer = ByteBuffer.allocate(4*blockSize); // apparently this buffer is backed by array
-    		blockBuffer.order(ByteOrder.nativeOrder());
-    	}
-    	else {
-    		blockBuffer.clear();
-    	}
-
-    	updatedStart = false;
-
-    	//write header words, some of which will be overwritten later when the values are determined,
-		blockBuffer.putInt(blockSize);
-		blockBuffer.putInt(blockNumber++);
-		blockBuffer.putInt(8);         // header size always 8
-		blockBuffer.putInt(0);         // start will be updated
-		blockBuffer.putInt(blockSize); // end is usually blocksize
-		blockBuffer.putInt(2);         // version is 2 or 3 (same format so just pick 2)
-		blockBuffer.putInt(0);         // reserved1 will be updated
-		blockBuffer.putInt(BlockHeader.MAGIC_NUMBER); // should be MAGIC_NUMBER
-    }
-
-
-    /**
-     * Close the underlying data output stream, and with it the file.
-     */
-    public void close() {
-        try {
-            // write final bytes, if there are any to be written
-            int position = blockBuffer.position();
-
-            if (position > 0) {
-                dataOutputStream.write(blockBuffer.array());
-            }
-
-            // finish writing file
-            dataOutputStream.close();
-        }
-        catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-    /**
-     * Write a bank to the file in evio version 2, 3 format.
-     *
-     * @param bank the bank to write.
-     * @throws EvioException
-     */
-    public void writeEvent(EvioBank bank) throws EvioException {
-    	if (bank == null) {
-    		throw new EvioException("Attempt to write null event using EventWriter");
-    	}
-
-        // if first event is being written, create buffer
-        if (blockBuffer == null) {
-            getCleanBuffer();
-        }
-    	
-    	//TODO call event.setComputedLength to make sure all headers have correct length?
-    	int bytelen = bank.getTotalBytes();
-    	ByteBuffer eventBuffer = ByteBuffer.allocate(bytelen);
-    	eventBuffer.order(ByteOrder.nativeOrder());
-
-    	bank.write(eventBuffer);
-
-    	// is the first event started in this buffer? If not, this is the first event that starts in this
-    	// block and we have to modify the start field accordingly
-    	if (!updatedStart) {
-    		updateStart(blockBuffer.position() / 4);
-    		updatedStart = true;
-    	}
-    	
-    	// update the reserved1 field because another event is starting in this physical record (block)
-		updateReserved1(++lastEventWritten);
-
-		// reset to top of event buffer
-		eventBuffer.position(0);
-
-		// the big question is: is there or is there not enough space in the block buffer to finish
-		// writing the event? If not we write as much as possible, flush, and repeat until we do
-		// have enough space to finish writing the event.
-		while (eventBuffer.remaining() > blockBuffer.remaining()) {
-			updateEnd(blockSize);
-			// finish filling current block buffer
-			int remaining = blockBuffer.remaining();
-			for (int i = 0; i < remaining; i++) {
-				blockBuffer.put(eventBuffer.get());
-			}
-			
-			//byte buffer is now full. Flush and reset
-			try {
-				dataOutputStream.write(blockBuffer.array());
-				getCleanBuffer();
-			}
-			catch (IOException e) {
-				e.printStackTrace();
-			}
-		}
-		// now we DO have enough space for remaining, if there is any more to write.
-		if (eventBuffer.remaining() > 0) {
-			// we are completing an event
-			blockBuffer.put(eventBuffer.array(), eventBuffer.position(), eventBuffer.remaining());
-			updateEnd(blockBuffer.position() / 4);
-		}
-	}
-
-    /**
-     * Update the block length field in the header using an absolute put.
-     * @param length the new value for block length.
-     */
-    private void updateBlockLength(int length) {
-        blockBuffer.putInt(BLOCK_LENGTH_OFFSET, length);
-    }
-
-    /**
-     * Update the start field in the header using an absolute put.
-     * @param start the new value for start.
-     */
-    private void updateStart(int start) {
-        blockBuffer.putInt(START_OFFSET, start);
-    }
-
-	/**
-	 * Update the end field in the header using an absolute put.
-	 * @param end the new value for end.
-	 */
-	private void updateEnd(int end) {
-		blockBuffer.putInt(END_OFFSET, end);
-	}
-	
-	/**
-	 * Update the reserved1 field in the header using an absolute put.
-	 * @param reserved1 the new value for reserved1.
-	 */
-	private void updateReserved1(int reserved1) {
-		blockBuffer.putInt(RESERVED1_OFFSET, reserved1);
-	}
-
-
-	/**
-	 * Main program for testing.
-	 * 
-	 * @param args ignored command line arguments.
-	 */
-	public static void main(String args[]) {
-//      String infile  = "C:\\Documents and Settings\\heddle\\My Documents\\out.ev";
-//      String outfile = "C:\\Documents and Settings\\heddle\\My Documents\\out_copy.ev";
-        String infile  = "../../testdata/out.ev";
-        String outfile = "../../testdata/out_copy.ev";
-		int count = 0;
-
-		try {
-			//an EvioFile object is used for reading
-			EvioFile inFile = new EvioFile(new File(infile));
-			//an EvioWriter object is used for writing
-			EventWriter eventWriter = new EventWriter(new File(outfile));
-            //EventWriter eventWriter = new EventWriter(new File(outfile), 8192, true);
-
-			EvioEvent event;
-			while ((event = inFile.parseNextEvent()) != null) {				
-//				System.out.println("EVENT LEN: " + event.getHeader().getLength());
-				eventWriter.writeEvent(event);
-				count++;
-			}
-			
-			eventWriter.close();
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-		}
-		catch (IOException e) {
-			e.printStackTrace();
-		}
-		System.out.println("copied: " + count + " events.");
-		
-		//compare the two files
-		EvioFile.compareEventFiles(new File(infile), new File(outfile));
-	}
-
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioBank.java
--- EvioBank.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,147 +0,0 @@

-package org.jlab.coda.jevio;
-
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-
-/**
- * This holds a CODA Bank structure. Mostly it has a header (a <code>BankHeader</code>) and the raw data stored as an
- * byte array.
- * 
- * @author heddle
- * 
- */
-public class EvioBank extends BaseStructure {
-
-	/**
-	 * The XML record tag for a segment.
-	 */
-	public static final String ELEMENT_NAME = "bank";
-
-    /** For general convenience, allow an object to be attached to an evio bank. */
-    transient protected Object attachment;
-
-
-	/**
-	 * Null constructor for a bank.
-	 */
-	public EvioBank() {
-		super(new BankHeader());
-	}
-
-	/**
-	 * Constructor using a provided BankHeader
-	 * 
-	 * @param bankHeader the header to use.
-	 * @see BankHeader
-	 */
-	public EvioBank(BankHeader bankHeader) {
-		super(bankHeader);
-	}
-	
-	/**
-	 * This is the general constructor to use for a Bank.
-	 * @param tag the tag for the bank header.
-	 * @param dataType the (enum) data type for the content of the bank.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public EvioBank(int tag, DataType dataType, int num) {
-		this(new BankHeader(tag, dataType, num));
-	}
-	
-	/**
-	 * This is the general constructor to use for a Bank.
-	 * @param tag the tag for the bank header.
-	 * @param dataType the (int) data type for the content of the bank.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public EvioBank(int tag, int dataType, int num) {
-		this(new BankHeader(tag, dataType, num));
-	}
-
-    /**
-     * Get the attached object.
-     * @return the attached object
-     */
-    public Object getAttachment() {
-        return attachment;
-    }
-
-    /**
-     * Set the attached object.
-     * @param attachment object to attach to this bank
-     */
-    public void setAttachment(Object attachment) {
-        this.attachment = attachment;
-    }
-
-	/**
-	 * This implements the abstract method from <code>BaseStructure</code>. It is a convenience method use instead of
-	 * "instanceof" to see what type of structure we have. Note: this returns the type of this structure, not the type
-	 * of data this structure holds.
-	 * 
-	 * @return the <code>StructureType</code> of this structure, which is a StructureType.BANK.
-	 * @see StructureType
-	 */
-	@Override
-	public StructureType getStructureType() {
-		return StructureType.BANK;
-	}
-	
-	/**
-	 * Write this bank structure out as an XML record.
-	 * @param xmlWriter the writer used to write the events.
-	 */
-	@Override
-	public void toXML(XMLStreamWriter xmlWriter) {
-
-		try {
-			commonXMLStart(xmlWriter);
-            if (DataType.getDataType(header.dataType).isStructure()) {
-			    xmlWriter.writeAttribute("content", xmlContentAttributeName);
-            }
-			xmlWriter.writeAttribute("data_type", String.format("0x%x", header.dataType));
-			xmlWriter.writeAttribute("tag", "" + header.tag);
-            xmlWriter.writeAttribute("num", "" + header.number);
-            xmlWriter.writeAttribute("length", "" + header.length);
-            xmlWriter.writeAttribute("ndata", "" + getNumberDataItems());
-            increaseXmlIndent();
-			commonXMLDataWrite(xmlWriter);
-            decreaseXmlIndent();
-			commonXMLClose(xmlWriter);
-		}
-		catch (XMLStreamException e) {
-			e.printStackTrace();
-		}
-	}
-
-	/**
-	 * Get the element name for the bank for writing to XML.
-	 * @return the element name for the structure for writing to XML.
-	 */
-	@Override
-	public String getXMLElementName() {
-		return ELEMENT_NAME;
-	}
-
-    /**
-     * Write myself out as a byte array of evio format data
-     * in the byte order given by {@link #getByteOrder}.
-     * This method is much more efficient than using {@link #write(java.nio.ByteBuffer)}.
-     *
-     * @return byte array containing evio format data of this bank in currently set byte order
-     */
-    public byte[] toArray() {
-
-        byte[] bArray = new byte[rawBytes.length + header.getHeaderLength()*4];
-
-        // write the header
-        header.toArray(bArray, 0, byteOrder);
-
-        // write the rest
-        System.arraycopy(rawBytes, 0, bArray, header.getHeaderLength()*4, rawBytes.length);
-
-        return bArray;
-    }
-
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioDictionaryEntry.java
--- EvioDictionaryEntry.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,200 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.util.StringTokenizer;
-
-/**
- * An entry into the evio dictionary.
- * 
- * @author heddle
- * 
- */
-public class EvioDictionaryEntry implements Comparable<EvioDictionaryEntry> {
-
-	/**
-	 * The tag will have to match the tag field in a segment.
-	 */
-	private int tag;
-
-	/**
-	 * The result of the number field being tokenized, with "." serving as the delimiter. These are tokens.
-	 */
-	private int numbers[];
-
-	/**
-	 * The nice name for this dictionary entry--the description.
-	 */
-	private String description;
-
-	/**
-	 * Constructor.
-	 * 
-	 * @param tag the string tag, will be converted into an int.
-	 * @param num the string num field, which might be <code>null</code>, and which will be tokenized (for possible
-	 *            ancestor matching) and converted into an array of ints.
-	 * @param description the nice name for this dictionary entry--the description.
-	 */
-	public EvioDictionaryEntry(String tag, String num, String description) {
-		this.description = description;
-
-		// the tag field should clean--no hierarchy
-		this.tag = Integer.parseInt(tag);
-
-		// The <code>num</code> value is a string, rather than an int, because it might represent
-		// a bank hierarchy. For example, a number of "2.3.1" means that a bank matches this
-		// entry if a) its num field in the header is 1, and b) its parent's num field is 3, and
-        // c) it's grandparent's num field is 2.
-		if (num != null) {
-			String tokens[] = tokens(num, ".");
-
-			numbers = new int[tokens.length];
-			// flip the order so numbers[0] is primary match.
-			int j = 0;
-			for (int i = tokens.length - 1; i >= 0; i--) {
-				numbers[j] = Integer.parseInt(tokens[i]);
-				j++;
-			}
-		}
-	}
-
-	/**
-	 * Checks if a structure matches this dictionary entry. This is more complicated than at first glance, because a
-	 * matching of not just the structure but also (for banks) the num fields of its immediate ancestors might be
-	 * required.
-	 * 
-	 * @param structure the structure to test.
-	 * @return <code>true</code> if the structure matches.
-	 */
-	public boolean match(BaseStructure structure) {
-		
-		if (structure instanceof EvioEvent) {
-			if ((numbers == null) || (numbers.length != 1)) {
-				return false;
-			}
-			BaseStructureHeader header = structure.header;
-			return (tag == header.tag) && (numbers[0] == header.number);
-		}
-		else if (structure instanceof EvioBank) {
-			if (structure.header.tag != tag) {
-				return false;
-			}
-			
-			if (numbers == null) {
-				return false;
-			}
-			
-			for (int i = 0; i < numbers.length; i++) {
-				BaseStructureHeader header = structure.header;
-				if (numbers[i] != header.number) {
-					return false;
-				}
-
-                structure = structure.getParent();
-                if (structure == null) {
-                    // Once we've reached the top event,
-                    // parent = null, but match is good. timmer 9/30/2010
-                    if (i >= numbers.length-1) {
-                        return true;
-                    }
-                    return false;
-                }
-                if (structure instanceof EvioSegment) {
-                    return false;
-                }
-                if (structure instanceof EvioTagSegment) {
-                    return false;
-                }
-            }
-			return true;
-		}
-		else {
-			BaseStructureHeader header = structure.header;
-			return (tag == header.tag);
-		}
-	}
-
-	/**
-	 * We sort so that the entries with the most number of ancestors match.
-	 * 
-	 * @param entry the object to compare against.
-	 */
-	@Override
-	public int compareTo(EvioDictionaryEntry entry) {
-        if (entry.numbers == null) return -1;
-        if (numbers == null) return 1;
-
-        // we want the entrys with the longer ancestor trail up top
-		if (numbers.length > entry.numbers.length) {
-			return -1;
-		}
-		if (numbers.length < entry.numbers.length) {
-			return 1;
-		}
-		// same number of tokens
-		for (int i = 0; i < numbers.length; i++) {
-			if (numbers[i] < entry.numbers[i]) {
-				return -1;
-			}
-			if (numbers[i] > entry.numbers[i]) {
-				return 1;
-			}
-		}
-
-		return 0;
-	}
-
-	/**
-	 * This method breaks a string into an array of tokens.
-	 * 
-	 * @param str the string to decompose.
-	 * @param token the token character.
-	 * @return an array of tokens.
-	 */
-	private String[] tokens(String str, String token) {
-		StringTokenizer t = new StringTokenizer(str, token);
-		int num = t.countTokens();
-		String tokens[] = new String[num];
-
-		for (int i = 0; i < num; i++) {
-			tokens[i] = t.nextToken();
-		}
-
-		return tokens;
-	}
-
-	/**
-	 * Get the nice, hopefully descriptive name for this entry.
-	 * 
-	 * @return the nice, hopefully descriptive name for this entry.
-	 */
-	public String getDescription() {
-		return description;
-	}
-
-	/**
-	 * Get a string representation of this entry.
-	 * 
-	 * @return a string representation of this entry.
-	 */
-	@Override
-	public String toString() {
-		String ns = null;
-		if (numbers != null) {
-			for (int i = numbers.length - 1; i >= 0; i--) {
-				if (ns == null) {
-					ns = "";
-				}
-				ns += numbers[i];
-				if (i != 0) {
-					ns += ".";
-				}
-			}
-		}
-		if (ns == null) {
-			return String.format("tag: %-4d description: %s", tag, description);
-		}
-		else {
-			return String.format("tag: %-4d num: %-10s description: %s", tag, ns, description);
-		}
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioEvent.java
--- EvioEvent.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,248 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.util.List;
-import java.util.Vector;
-
-import javax.swing.tree.DefaultTreeModel;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-
-/**
- * An event is really just the outer, primary bank. That is, the first structure in an event (aka logical record, aka
- * buffer) must be a bank, probably a bank of banks.
- * 
- * The Event trivially extends bank, just so there can be a distinct <code>EvioEvent</code> class, for clarity.
- * 
- * @author heddle
- * 
- */
-public class EvioEvent extends EvioBank {
-		
-	/**
-	 * The XML record tag for an event.
-	 */
-	public static final String ELEMENT_NAME = "event";
-
-	/**
-	 * As the event is parsed, it is parsed into a tree.
-	 */
-	protected DefaultTreeModel treeModel;
-	
-	/**
-	 * This is not the "num" field from the header, but rather a number [1..] indicating
-	 * which event this was in the event file from which it was read. 
-	 */
-	private int eventNumber;
-
-
-    /**
-	 * Explicit null constructor for evio event.
-	 */
-	public EvioEvent() {
-	}
-	
-    /**
-     * Constructor using a provided BankHeader.
-     *
-     * @param bankHeader the header to use.
-     * @see BankHeader
-     */
-    public EvioEvent(BankHeader bankHeader) {
-        super(bankHeader);
-    }
-
-	/**
-	 * This is a general constructor to use for an EvioEvent.
-     *
-	 * @param tag the tag for the event header (which is just a bank header).
-	 * @param dataType the (enum) data type for the content of the bank.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public EvioEvent(int tag, DataType dataType, int num) {
-		this(new BankHeader(tag, dataType, num));
-	}
-
-	/**
-	 * This is a general constructor to use for an EvioEvent.
-     *
-	 * @param tag the tag for the event header (which is just a bank header).
-	 * @param dataType the (int) data type for the content of the bank.
-	 * @param num sometimes, but not necessarily, an ordinal enumeration.
-	 */
-	public EvioEvent(int tag, int dataType, int num) {
-		this(new BankHeader(tag, dataType, num));
-	}
-
-	/**
-	 * Create a string representation of the event.
-	 * @return a string representation of the event.
-	 */
-	@Override
-	public  String toString() {
-		
-		String description = getDescription();
-		if (NameProvider.NO_NAME_STRING.equals(description)) {
-			description = null;
-		}
-		
-		String s = "<Event> " + " len (ints): " + header.length + " " + " tag: " + header.tag + " num: " + header.number;
-		if (description != null) {
-			s += " [" + description + "]";
-		}
-		return s;
-	}
-	
-	/**
-	 * Get the tree model representing this event. This would have been generated
-	 * as the event was being parsed.
-	 * @return the tree model representing this event.
-	 */
-	public DefaultTreeModel getTreeModel() {
-		return treeModel;
-	}
-	
-	/**
-	 * Inserts a child structure into the event's JTree. This is called when the event is being parsed,
-	 * and when an event is being created.
-	 * @param child the child structure being added to the tree.
-	 * @param parent the parent structure of the new child.
-	 */
-	public void insert(BaseStructure child, BaseStructure parent) {
-		treeModel.insertNodeInto(child, parent, parent.getChildCount());
-	}
-	
-	/**
-	 * Visit all the structures in this event (including the event itself--which is considered its own descendant). 
-	 * This is similar to listening to the event as it is being parsed, but is done to a complete (already) parsed event.
-	 * @param listener an listener to notify as each structure is visited.
-	 */
-	public void vistAllStructures(IEvioListener listener) {
-		visitAllDescendants(this, listener, null);
-	}
-
-	/**
-	 * Visit all the structures in this event (including the event itself--which is considered its own descendant) in a depth first manner.
-	 * @param listener an listener to notify as each structure is visited.
-	 * @param filter an optional filter that must "accept" structures before they are passed to the listener. If <code>null</code>, all
-	 * structures are passed. In this way, specific types of structures can be captured.
-	 */
-	public void vistAllStructures(IEvioListener listener, IEvioFilter filter) {
-		visitAllDescendants(this, listener, filter);
-	}
-
-	/**
-	 * Visit all the descendants of a given structure (which is considered a descendant of itself.)
-	 * 
-	 * @param structure the starting structure.
-	 * @param listener an listener to notify as each structure is visited.
-	 * @param filter an optional filter that must "accept" structures before they are passed to the listener. If
-	 *            <code>null</code>, all structures are passed. In this way, specific types of structures can be
-	 *            captured.
-	 */
-	private void visitAllDescendants(BaseStructure structure, IEvioListener listener, IEvioFilter filter) {
-		
-		if (listener != null) {
-			boolean accept = true;
-			if (filter != null) {
-				accept = filter.accept(structure.getStructureType(), structure.header);
-			}
-			
-			if (accept) {
-			listener.gotStructure(this, structure);
-			}
-		}
-		
-		if (!(structure.isLeaf())) {
-			for (BaseStructure child : structure.getChildren()) {
-				visitAllDescendants(child, listener, filter);
-			}
-		}
-	}
-	
-	/**
-	 * Visit all the descendant structures, and collect those that pass a filter.
-	 * @param filter the filter that must be passed. If <code>null</code>, this will return all the structures.
-	 * @return a collection of all structures that are accepted by a filter.
-	 */
-	public List<BaseStructure> getMatchingStructures(IEvioFilter filter) {
-		final Vector<BaseStructure> structures = new Vector<BaseStructure>(25, 10);
-		
-		IEvioListener listener = new IEvioListener() {
-            @Override
-            public void startEventParse(EvioEvent evioEvent) { }
-
-            @Override
-            public void endEventParse(EvioEvent evioEvent) { }
-            
-			@Override
-			public void gotStructure(EvioEvent evioEvent, IEvioStructure structure) {
-				structures.add((BaseStructure)structure);
-			}
-			
-		};
-		
-		vistAllStructures(listener, filter);
-		
-		if (structures.size() == 0) {
-			return null;
-		}
-		return structures;
-	}
-	
-    /**
-     * This returns a number [1..] indicating which event this was in the event file from which
-     * it was read. It is not the "num" field from the header.
-     * @return a number [1..] indicating which event this was in the event file from which
-     * it was read.
-     */
-    public int getEventNumber() {
-        return eventNumber;
-    }
-
-	/**
-	 * This sets a number [1..] indicating which event this was in the event file from which
-	 * it was read. It is not the "num" field from the header.
-	 * @param eventNumber a number [1..] indicating which event this was in the event file from which
-	 * it was read.
-	 */
-	public void setEventNumber(int eventNumber) {
-		this.eventNumber = eventNumber;
-	}
-
-	/**
-	 * Write this event structure out as an XML record.
-	 * @param xmlWriter the writer used to write the events.
-	 */
-	@Override
-	public void toXML(XMLStreamWriter xmlWriter) {
-
-		try {
-			int totalLen = header.length + 1;
-			xmlWriter.writeComment(" Buffer " + getEventNumber() + " contains " + totalLen + " words (" + 4*totalLen + " bytes)");
-			commonXMLStart(xmlWriter);
-			xmlWriter.writeAttribute("format", "evio");
-			xmlWriter.writeAttribute("count", "" + getEventNumber());
-            if (DataType.getDataType(header.dataType).isStructure()) {
-			    xmlWriter.writeAttribute("content", xmlContentAttributeName);
-            }
-			xmlWriter.writeAttribute("data_type", String.format("0x%x", header.dataType));
-			xmlWriter.writeAttribute("length", "" + header.length);
-			xmlWriter.writeAttribute("tag", "" + header.tag);
-			xmlWriter.writeAttribute("num", "" + header.number);
-			commonXMLClose(xmlWriter);
-		}
-		catch (XMLStreamException e) {
-			e.printStackTrace();
-		}
-	}
-
-	/**
-	 * Get the element name for the bank for writing to XML.
-	 * @return the element name for the structure for writing to XML.
-	 */
-	@Override
-	public String getXMLElementName() {
-		return ELEMENT_NAME;
-	}
-	
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioException.java
--- EvioException.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,43 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This is a general exception used to indicate a problem in the Jevio package.
- * 
- * @author heddle
- * 
- */
-@SuppressWarnings("serial")
-public class EvioException extends Exception {
-
-    /**
-     * Create an EVIO Exception indicating an error specific to the EVIO system.
-     * {@inheritDoc}<p/>
-     *
-     * @param message {@inheritDoc}<p/>
-     */
-    public EvioException(String message) {
-        super(message);
-    }
-
-    /**
-     * Create an EVIO Exception with the specified message and cause.
-     * {@inheritDoc}<p/>
-     *
-     * @param message {@inheritDoc}<p/>
-     * @param cause   {@inheritDoc}<p/>
-     */
-    public EvioException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-    /**
-     * Create an EVIO Exception with the specified cause.
-     * {@inheritDoc}<p/>
-     *
-     * @param cause {@inheritDoc}<p/>
-     */
-    public EvioException(Throwable cause) {
-        super(cause);
-    }
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioFile.java
--- EvioFile.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,1203 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.io.*;
-import java.nio.*;
-import java.nio.channels.FileChannel;
-
-import javax.xml.stream.FactoryConfigurationError;
-import javax.xml.stream.XMLOutputFactory;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-
-/**
- * This is the a class of interest to the user. Create an <code>EvioFile</code> from a <code>File</code>
- * object corresponding to an event file, and from this class you can test the file for consistency and,
- * more importantly, you can call <code>parseNextEvent</code> to get new events and to stream the embedded
- * structures to an IEvioListener.
- * 
- * The streaming effect of parsing an event is that the parser will read the event and hand off structures,
- * such as banks, to any IEvioListeners. For those familiar with XML, the event is processed SAX-like.
- * It is up to the listener to decide what to do with the structures.
- * <p>
- * As an alternative to stream processing, after an event is parsed, the user can use the events treeModel
- * for access to the structures. For those familiar with XML, the event is processed DOM-like.
- * <p>
- * NOTE: Even though this class has a constructor that accepts an i/o mode, that is for backwards
- * compatibility only. An <code>EvioFile</code> is used for reading and parsing events only.
- * To write an event file, use an <code>EventWriter</code> object.
- *
- * @author heddle
- * 
- */
-public class EvioFile {
-
-	/**
-	 * This <code>enum</code> denotes the status of a read. <br>
-	 * SUCCESS indicates a successful read. <br>
-	 * END_OF_FILE indicates that we cannot read because an END_OF_FILE has occurred. Technically this means that what
-	 * ever we are trying to read is larger than the buffer's unread bytes.<br>
-	 * EVIO_EXCEPTION indicates that an EvioException was thrown during a read, possibly due to out of range values,
-	 * such as a negative start position.<br>
-	 * UNKNOWN_ERROR indicates that an unrecoverable error has occurred.
-	 */
-	public static enum ReadStatus {
-		SUCCESS, END_OF_FILE, EVIO_EXCEPTION, UNKNOWN_ERROR
-	}
-
-	/**
-	 * This <code>enum</code> denotes the status of a write.<br>
-	 * SUCCESS indicates a successful write. <br>
-	 * CANNOT_OPEN_FILE indicates that we cannot write because the destination file cannot be opened.<br>
-	 * EVIO_EXCEPTION indicates that an EvioException was thrown during a write.<br>
-	 * UNKNOWN_ERROR indicates that an unrecoverable error has occurred.
-	 */
-	public static enum WriteStatus {
-		SUCCESS, CANNOT_OPEN_FILE, EVIO_EXCEPTION, UNKNOWN_ERROR
-	}
-
-	/**
-	 * Offset to get magic number from start of file.
-	 */
-	private static final int MAGIC_OFFSET = 28;
-	
-	/**
-	 * The buffer representing a map of the input file.
-	 */
-	private MappedByteBuffer mappedByteBuffer;
-
-    /**
-     * Endianness of the data, either {@link ByteOrder#BIG_ENDIAN} or {@link ByteOrder#LITTLE_ENDIAN}.
-     */
-    private ByteOrder byteOrder;
-
-	/**
-	 * The current block header.
-	 */
-	private BlockHeader blockHeader = new BlockHeader();
-	
-	/**
-	 * Root element tag for XML file
-	 */
-	private static final String ROOT_ELEMENT = "evio-data";
-
-	/**
-	 * Used to assign a transient number [1..n] to events as they are
-	 */
-	private int eventNumber = 0;
-
-	/**
-	 * This is the number of events in the file. It is not computed unless asked for, and if asked for it is computed
-	 * and cached in this variable.
-	 */
-	private int eventCount = -1;
-
-    /**
-     * Absolute path of the underlying file.
-     */
-    private String path;
-
-	
-	/**
-	 * Creates an event file for reading.
-	 * 
-	 * @param file the file that contains EVIO events.
-	 * @throws IOException
-	 */
-	public EvioFile(File file) throws IOException {
-		FileInputStream fileInputStream = new FileInputStream(file);
-        path = new String(file.getAbsolutePath());
-		FileChannel inputChannel = fileInputStream.getChannel();
-		mapFile(inputChannel);
-		inputChannel.close(); // this object is no longer needed
-        // set buffer to beginning
-        mappedByteBuffer.position(0);
-    }
-
-	/**
-	 * Creates an event file.
-	 * 
-	 * @param path the full path to the file that contains events.
-	 * For writing event files, use an <code>EventWriter</code> object.
-	 * @see EventWriter
-	 * @throws IOException
-	 */
-	public EvioFile(String path) throws IOException {
-		this(new File(path));
-	}
-
-    /**
-     * Get the path to the file.
-     * @return path to the file
-     */
-    public String getPath() {
-        return path;
-    }
-
-    /**
-     * Get the number of events remaining in the file.
-     *
-     * @return number of events remaining in the file
-     * @throws EvioException if failed reading from coda v3 file
-     */
-    public int getNumEventsRemaining() throws EvioException {
-        return getEventCount() - eventNumber;
-    }
-
-	/**
-	 * Maps the file into memory. The data are not actually loaded in memory-- subsequent reads will read
-	 * random-access-like from the file.
-	 * 
-	 * @param inputChannel the input channel.
-	 */
-	private synchronized void mapFile(FileChannel inputChannel) throws IOException {
-		long sz = inputChannel.size();
-//System.out.println("mapFile: size = " + sz);
-		mappedByteBuffer = inputChannel.map(FileChannel.MapMode.READ_ONLY, 0L, sz);
-	}
-
-	/**
-	 * Obtain the file size using the memory mapped buffer's capacity, which should be the same.
-	 * 
-	 * @return the file size in bytes--actually the mapped memory size.
-	 */
-	public int fileSize() {
-		return mappedByteBuffer.capacity();
-	}
-
-	/**
-	 * Get the memory mapped buffer corresponding to the event file.
-	 * 
-	 * @return the memory mapped buffer corresponding to the event file.
-	 */
-	public MappedByteBuffer getMappedByteBuffer() {
-		return mappedByteBuffer;
-	}
-
-	/**
-	 * Reads the block (physical record) header. Assumes the mapped buffer is positioned
-     * at the start of the next block header (physical record.)<br>
-     *
-	 * A Bank header is 8, 32-bit ints. The first int is the size of the block in ints
-     * (not counting the length itself, i.e., the number of ints to follow).
-	 * 
-	 * Most users should have no need for this method, since most applications do care about the block
-     * (physical record) header.
-	 */
-	protected synchronized ReadStatus nextBlockHeader() {
-		// have enough remaining?
-		if (mappedByteBuffer.remaining() < 32) {
-			mappedByteBuffer.clear();
-			return ReadStatus.END_OF_FILE;
-		}
-
-		// set the byte order to match the file's ordering
-		try {
-			// Check the magic number for endianness. This requires
-			// peeking ahead 7 ints or 24 bytes. Set the endianness
-            // once we figure out what it is (buffer defaults to big endian).
-            byteOrder = mappedByteBuffer.order();
-			int magicNumber = mappedByteBuffer.getInt(MAGIC_OFFSET);
-//System.out.println("nextBlockHeader: actual magic number = " + Integer.toHexString(BlockHeader.MAGIC_NUMBER));
-//System.out.println("nextBlockHeader: read magic number as " + Integer.toHexString(magicNumber));
-
-			if (magicNumber != BlockHeader.MAGIC_NUMBER) {
-                // Originally checked ByteOrder.nativeOrder() which is NOT what you want -  timmer
-				if (byteOrder == ByteOrder.BIG_ENDIAN) {
-                    byteOrder = ByteOrder.LITTLE_ENDIAN;
-//System.out.println("nextBlockHeader: reset byte order to " + ByteOrder.LITTLE_ENDIAN);
-				}
-				else {
-                    byteOrder = ByteOrder.BIG_ENDIAN;
-//System.out.println("nextBlockHeader: reset byte order to " + ByteOrder.BIG_ENDIAN);
-				}
-                mappedByteBuffer.order(byteOrder);
-			}
-			else {
-//System.out.println("nextBlockHeader: byte order = " + byteOrder);
-			}
-
-			try {
-				// cache the starting position
-				blockHeader.setBufferStartingPosition(mappedByteBuffer.position());
-
-				// Now read the header data. It's a little trickier now that there are
-                // several versions to be concerned about. Read all quantities into
-                // temp variables, set the version FIRST, then set the other quantities last
-                // as they may depend on the version number.
-                int[] header = new int[8];
-                for (int i=0; i<8; i++) {
-                    header[i] = mappedByteBuffer.getInt();
-                }
-
-                int version = header[5] & 0xff;
-                if (version != 2 && version != 3) {
-                    // we got the wrong evio version here, throw an exception
-                    throw new EvioException("Reading file of unsupported evio version (" + version + ")");
-                }
-
-                blockHeader.setVersion(version);
-				blockHeader.setSize(header[0]);
-				blockHeader.setNumber(header[1]);
-				blockHeader.setHeaderLength(header[2]);
-				blockHeader.setStart(header[3]);
-				blockHeader.setEnd(header[4]);
-				blockHeader.setReserved1(header[6]); // also event count in verson 4
-				blockHeader.setMagicNumber(header[7]);
-			}
-			catch (EvioException e) {
-				e.printStackTrace();
-				return ReadStatus.EVIO_EXCEPTION;
-			}
-		}
-		catch (BufferUnderflowException a) {
-System.err.println("ERROR endOfBuffer " + a);
-			mappedByteBuffer.clear();
-			return ReadStatus.UNKNOWN_ERROR;
-		}
-
-		return ReadStatus.SUCCESS;
-	}
-
-
-   /**
-     * Get the next event in the file. As useful as this sounds, most applications will probably call
-     * {@link #parseNextEvent() parseNextEvent} instead, since it combines combines getting the next
-     * event with parsing the next event.<p>
-     *
-     * @return the next event in the file. On error it throws an EvioException. On end of file, it returns
-     *         <code>null</code>.
-     * @throws EvioException
-     */
-    public synchronized EvioEvent nextEvent() throws EvioException {
-        EvioEvent event = new EvioEvent();
-        BaseStructureHeader header = event.getHeader();
-
-        // Are we at the top of the file?
-        if (mappedByteBuffer.position() == 0) {
-            ReadStatus status = nextBlockHeader();
-            if (status != ReadStatus.SUCCESS) {
-                throw new EvioException("Failed reading block header in nextEvent.");
-            }
-//System.out.println("nextEvent: BLOCK HEADER :\n" + blockHeader.toString());
-        }
-
-        // How many bytes remain in this block?
-        // Must see if we have to deal with crossing physical record boundaries.
-        int bytesRemaining = blockBytesRemaining();
-        if (bytesRemaining < 0) {
-            throw new EvioException("Number of block bytes remaining is negative.");
-        }
-
-        // Are we exactly at the end of the block (physical record)?
-        if (bytesRemaining == 0) {
-            ReadStatus status = nextBlockHeader();
-            if (status == ReadStatus.SUCCESS) {
-//System.out.println("nextEvent: BLOCK HEADER:\n" + blockHeader.toString());
-                return nextEvent();
-            }
-            else if (status == ReadStatus.END_OF_FILE) {
-                return null;
-            }
-            else {
-                throw new EvioException("Failed reading block header in nextEvent.");
-            }
-        }
-        // Or have we already read in the last event?
-        else if (blockHeader.getBufferEndingPosition() == mappedByteBuffer.position()) {
-            return null;
-        }
-
-        // No matter what, we can get the length of the next event.
-        // A non positive length indicates eof;
-        int length = mappedByteBuffer.getInt();
-        if (length < 1) {
-            return null;
-        }
-
-        header.setLength(length);
-        bytesRemaining -= 4; // just read in 4 bytes
-
-       // If we were unlucky, after reading the length there are no bytes remaining in this bank.
-       if (bytesRemaining == 0) {
-           ReadStatus status = nextBlockHeader();
-           if (status == ReadStatus.END_OF_FILE) {
-               return null;
-           }
-           else if (status != ReadStatus.SUCCESS) {
-               throw new EvioException("Failed reading block header in nextEvent.");
-           }
-           bytesRemaining = blockBytesRemaining();
-       }
-
-        // Now should be good to go, except data may cross block boundary
-        // in any case, should be able to read the rest of the header.
-        if (byteOrder == ByteOrder.BIG_ENDIAN) {
-            // interested in bit pattern, not negative numbers
-            header.setTag(ByteDataTransformer.shortBitsToInt(mappedByteBuffer.getShort()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(mappedByteBuffer.get()));
-            header.setNumber(ByteDataTransformer.byteBitsToInt(mappedByteBuffer.get()));
-        }
-        else {
-            header.setNumber(ByteDataTransformer.byteBitsToInt(mappedByteBuffer.get()));
-            header.setDataType(ByteDataTransformer.byteBitsToInt(mappedByteBuffer.get()));
-            header.setTag(ByteDataTransformer.shortBitsToInt(mappedByteBuffer.getShort()));
-        }
-        bytesRemaining -= 4; // just read in 4 bytes
-
-        // get the raw data
-        int eventDataSizeInts = header.getLength() - 1;
-        int eventDataSizeBytes = 4 * eventDataSizeInts;
-
-        try {
-            byte bytes[] = new byte[eventDataSizeBytes];
-
-            int bytesToGo = eventDataSizeBytes;
-            int offset = 0;
-
-            // be in while loop if have to cross block boundary[ies].
-            while (bytesToGo > bytesRemaining) {
-                mappedByteBuffer.get(bytes, offset, bytesRemaining);
-
-                ReadStatus status = nextBlockHeader();
-                if (status == ReadStatus.END_OF_FILE) {
-                    return null;
-                }
-                else if (status != ReadStatus.SUCCESS) {
-                    throw new EvioException("Failed reading block header after crossing boundary in nextEvent.");
-                }
-//System.out.println("nextEvent: BLOCK HEADER:\n" + blockHeader.toString());
-                bytesToGo -= bytesRemaining;
-                offset += bytesRemaining;
-                bytesRemaining = blockBytesRemaining();
-            }
-
-            // last (perhaps only) read.
-            mappedByteBuffer.get(bytes, offset, bytesToGo);
-            event.setRawBytes(bytes);
-            event.setByteOrder(byteOrder); // add this to track endianness, timmer
-            event.setEventNumber(++eventNumber);
-            return event;
-        }
-        catch (OutOfMemoryError ome) {
-            System.err.println("Out Of Memory\n" +
-                    "eventDataSizeBytes = " + eventDataSizeBytes + "\n" +
-                            "bytes Remaining = " + bytesRemaining + "\n" +
-                            "event Count: " + eventCount);
-            return null;
-        }
-        catch (Exception e) {
-            return null;
-        }
-    }
-
-	/**
-	 * This is the workhorse method. It retrieves the next event from the file, and then parses is SAX-like. It will
-	 * drill down and uncover all structures (banks, segments, and tagsegments) and notify any interested listeners.
-	 * 
-	 * @return the event that was parsed. On error it throws an EvioException. On end of file, it returns
-	 *         <code>null</code>.
-	 * @throws EvioException
-	 */
-	public synchronized EvioEvent parseNextEvent() throws EvioException {
-		EvioEvent event = nextEvent();
-		if (event != null) {
-			parseEvent(event);
-		}
-		return event;
-	}
-
-	/**
-	 * This will parse an event, SAX-like. It will drill down and uncover all structures (banks, segments, and
-	 * tagsegments) and notify any interested listeners.
-	 * 
-	 * As useful as this sounds, most applications will probably call {@link #parseNextEvent() parseNextEvent} instead,
-	 * since it combines combines getting the next event with parsing the next event .
-	 * 
-	 * @param evioEvent the event to parse.
-	 * @throws EvioException
-	 */
-	public synchronized void parseEvent(EvioEvent evioEvent) throws EvioException {
-		EventParser.getInstance().parseEvent(evioEvent);
-	}
-
-	/**
-	 * Get the number of bytes remaining in the current block (physical record). This is used for pathology checks like
-	 * crossing the block boundary.
-	 * 
-	 * @return the number of bytes remaining in the current block (physical record).
-	 */
-	private int blockBytesRemaining() {
-		try {
-			return blockHeader.bytesRemaining(mappedByteBuffer.position());
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-			return -1;
-		}
-	}
-
-	/**
-	 * The equivalent of rewinding the file. What it actually does is set the position of the mapped memory buffer back
-	 * to 0. This method, along with the two <code>position</code> and the <code>close</code> method, allows
-	 * applications to treat this in a normal random access file manner.
-	 */
-	public void rewind() {
-		mappedByteBuffer.position(0);
-		eventNumber = 0;
-	}
-
-	/**
-	 * This is equivalent to obtaining the current position in the file. What it actually does is return the position of
-	 * the mapped memory buffer. This method, along with the <code>rewind</code>, <code>position(int)</code> and the
-	 * <code>close</code> method, allows applications to treat this in a normal random access file manner.
-	 * 
-	 * @return the position of the file.
-	 */
-	public int position() {
-		return mappedByteBuffer.position();
-	}
-
-	/**
-	 * This is equivalent to setting the current position in the file. What it actually does is set the position of the
-	 * mapped memory buffer. This method, along with the <code>rewind</code>, <code>position()</code> and the
-	 * <code>close</code> method, allows applications to treat this in a normal random access file manner.
-	 * 
-	 * @param position the new position of the file.
-	 */
-	public void position(int position) {
-		mappedByteBuffer.position(position);
-	}
-
-	/**
-	 * This is equivalent to closing the file. What it actually does is clear all data from the mapped memory buffer,
-	 * and sets its position to 0. This method, along with the <code>rewind</code> and the two <code>position()</code>
-	 * methods, allows applications to treat this in a normal random access file manner.
-	 */
-	public void close() {
-		mappedByteBuffer.clear();
-	}
-
-	/**
-	 * This returns the current (active) block (physical record) header. Since most users have no interest in physical
-	 * records, this method should not be used often. Mostly it is used by the test programs in the
-	 * <code>EvioFileTest</code> class.
-	 * 
-	 * @return the current block header.
-	 */
-	public BlockHeader getCurrentBlockHeader() {
-		return blockHeader;
-	}
-
-	/**
-	 * Go to a specific event in the file. The events are numbered 1..N. This number is transient--it is not part of the
-	 * event as stored in the evio file.
-	 * 
-	 * @param evNumber the event number in a 1..N counting sense, from the start of the file.
-	 */
-	public EvioEvent gotoEventNumber(int evNumber) {
-
-		if (evNumber < 1) {
-			return null;
-		}
-
-		// rewind
-		rewind();
-		EvioEvent event;
-
-		try {
-			// get the first evNumber - 1 events without parsing
-			for (int i = 1; i < evNumber; i++) {
-				event = nextEvent();
-				if (event == null) {
-					throw new EvioException("Asked to go to event: " + evNumber + ", which is beyond the end of file");
-				}
-			}
-			// get one more event, the evNumber'th event, with parsing
-			return parseNextEvent();
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-		}
-		return null;
-	}
-
-	/**
-	 * Rewrite the entire file to XML.
-	 * 
-	 * @param path the path to the XML file.
-	 * @return the status of the write.
-	 */
-	public WriteStatus toXMLFile(String path) {
-		return toXMLFile(path, null);
-	}
-
-	/**
-	 * Rewrite the entire file to XML.
-	 * 
-	 * @param path the path to the XML file.
-	 * @param progressListener and optional progress listener, can be <code>null</code>.
-	 * @return the status of the write.
-	 * @see IEvioProgressListener
-	 */
-	public WriteStatus toXMLFile(String path, IEvioProgressListener progressListener) {
-		FileOutputStream fos;
-
-		try {
-			fos = new FileOutputStream(path);
-		}
-		catch (FileNotFoundException e) {
-			e.printStackTrace();
-			return WriteStatus.CANNOT_OPEN_FILE;
-		}
-
-		XMLStreamWriter xmlWriter = null;
-		try {
-			xmlWriter = XMLOutputFactory.newInstance().createXMLStreamWriter(fos);
-			xmlWriter.writeStartDocument();
-			xmlWriter.writeCharacters("\n");
-			xmlWriter.writeComment("Event source file: " + path);
-
-			// start the root element
-			xmlWriter.writeCharacters("\n");
-			xmlWriter.writeStartElement(ROOT_ELEMENT);
-			xmlWriter.writeAttribute("numevents", "" + getEventCount());
-
-			// now loop through the events
-			// rewind
-			rewind();
-			EvioEvent event;
-			try {
-				while ((event = parseNextEvent()) != null) {
-					event.toXML(xmlWriter);
-					// anybody interested in progress?
-					if (progressListener != null) {
-						progressListener.completed(event.getEventNumber(), getEventCount());
-					}
-				}
-			}
-			catch (EvioException e) {
-				e.printStackTrace();
-				return WriteStatus.UNKNOWN_ERROR;
-			}
-
-			// done. Close root element, end the document, and flush.
-			xmlWriter.writeCharacters("\n");
-			xmlWriter.writeEndElement();
-			xmlWriter.writeEndDocument();
-			xmlWriter.flush();
-			xmlWriter.close();
-
-			try {
-				fos.close();
-			}
-			catch (IOException e) {
-				e.printStackTrace();
-			}
-		}
-		catch (XMLStreamException e) {
-			e.printStackTrace();
-			return WriteStatus.UNKNOWN_ERROR;
-		}
-        catch (FactoryConfigurationError e) {
-            return WriteStatus.UNKNOWN_ERROR;
-        }
-        catch (EvioException e) {
-            return WriteStatus.EVIO_EXCEPTION;
-        }
-
-		// TODO something better than just rewind again?
-		rewind();
-		System.out.println("XML write was successful");
-		return WriteStatus.SUCCESS;
-	}
-
-    /**
-     * This is the number of events in the file. It is not computed unless asked for, and if asked for it is computed
-     * and cached.
-     *
-     * @return the number of events in the file.
-     * @throws EvioException
-     */
-    public int getEventCount() throws EvioException {
-
-        if (eventCount < 0) {
-            rewind();
-            eventCount = 0;
-
-            while ((nextEvent()) != null) {
-                eventCount++;
-            }
-
-            rewind();
-        }
-
-        return eventCount;
-    }
-
-	/**
-	 * Method used for diagnostics. It compares two event files. It checks the following (in order):<br>
-	 * <ol>
-	 * <li> That neither file is null.
-	 * <li> That both files exist.
-	 * <li> That neither file is a directory.
-	 * <li> That both files can be read.
-	 * <li> That both files are the same size.
-	 * <li> That both files contain the same number of events.
-	 * <li> Finally, that they are the same in a byte-by-byte comparison.
-	 * </ol> 
-	 * NOTE: Two files with the same events but different physical record size will be reported as different. They will fail the same size test.
-	 * @return <code>true</code> if the files are, byte-by-byte, identical.
-	 */
-	public static boolean compareEventFiles(File evFile1, File evFile2) {
-		
-		if ((evFile1 == null) || (evFile2 == null)) {
-			System.out.println("In compareEventFiles, one or both files are null.");
-			return false;
-		}
-		
-		if (!evFile1.exists() || !evFile2.exists()) {
-			System.out.println("In compareEventFiles, one or both files do not exist.");
-			return false;
-		}
-		
-		if (evFile1.isDirectory() || evFile2.isDirectory()) {
-			System.out.println("In compareEventFiles, one or both files is a directory.");
-			return false;
-		}
-		
-		if (!evFile1.canRead() || !evFile2.canRead()) {
-			System.out.println("In compareEventFiles, one or both files cannot be read.");
-			return false;
-		}
-		
-		String name1 = evFile1.getName();
-		String name2 = evFile2.getName();
-		
-		long size1 = evFile1.length();
-		long size2 = evFile2.length();
-		
-		if (size1 == size2) {
-			System.out.println(name1 + " and " + name2 + " have the same length: " + size1);
-		}
-		else {
-			System.out.println(name1 + " and " + name2 + " have the different lengths.");
-			System.out.println(name1 + ": " + size1);
-			System.out.println(name2 + ": " + size2);
-			return false;
-		}
-		
-		try {
-			EvioFile evioFile1 = new EvioFile(evFile1);
-			EvioFile evioFile2 = new EvioFile(evFile2);
-			int evCount1 = evioFile1.getEventCount();
-			int evCount2 = evioFile2.getEventCount();
-			if (evCount1 == evCount2) {
-				System.out.println(name1 + " and " + name2 + " have the same #events: " + evCount1);
-			}
-			else {
-				System.out.println(name1 + " and " + name2 + " have the different #events.");
-				System.out.println(name1 + ": " + evCount1);
-				System.out.println(name2 + ": " + evCount2);
-				return false;
-			}
-		}
-        catch (EvioException e) {
-            e.printStackTrace();
-            return false;
-        }
-        catch (IOException e) {
-            e.printStackTrace();
-            return false;
-        }
-
-
-		System.out.print("Byte by byte comparison...");
-		System.out.flush();
-		
-		int onetenth = (int)(1 + size1/10);
-		
-		//now a byte-by-byte comparison
-		try {
-			FileInputStream fis1 = new FileInputStream(evFile1);
-			FileInputStream fis2 = new FileInputStream(evFile1);
-			
-			for (int i = 0; i < size1; i++) {
-				try {
-					int byte1 = fis1.read();
-					int byte2 = fis2.read();
-					
-					if (byte1 != byte2) {
-						System.out.println(name1 + " and " + name2 + " different at byte offset: " + i);
-						return false;
-					}
-					
-					if ((i % onetenth) == 0) {
-						System.out.print(".");
-						System.out.flush();
-					}
-				}
-				catch (IOException e) {
-					e.printStackTrace();
-					return false;
-				}
-			}
-			
-			System.out.println("");
-			
-			try {
-				fis1.close();
-				fis2.close();
-			}
-			catch (IOException e) {
-				e.printStackTrace();
-			}
-		}
-		catch (FileNotFoundException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-		
-		
-		System.out.println("files " + name1 + " and " + evFile2.getPath() + " are identical.");
-		return true;
-	}
-
-
-    /**
-      * Array of ints, sequential, 1..size, for test purposes.
-      * @param size the size of the array.
-      * @return the fake int array.
-      */
-     private static int[] fakeIntArray(int size) {
-         int[] array = new int[size];
-         for (int i = 0; i < size; i++) {
-             array[i] = 0x040302010;
-         }
-         return array;
-     }
-
-     /** For testing only */
-     public static void main(String args[]) {
-//         //create an event writer to write out the test events.
-         String fileName  = "../../testdata/littleOut.ev";
-//         EventWriter eventWriter = null;
-//         File file = new File(fileName);
-//
-//         //count the events we make for testing
-//         int eventNumber = 1;
-//
-//         //use a tag of 11 for events--for no particular reason
-//         int tag = 11;
-//
-//         try {
-//             eventWriter = new EventWriter(file);
-//             //first event-- a trivial event containing an array of ints.
-//             EventBuilder eventBuilder = new EventBuilder(tag, DataType.INT32, eventNumber++);
-//             EvioEvent event1 = eventBuilder.getEvent();
-//             //should end up with int array 1..25,1..10
-//             eventBuilder.appendIntData(event1, fakeIntArray(10));
-//             eventWriter.writeEvent(event1);
-//         }
-//         catch (EvioException e) {
-//             e.printStackTrace();
-//         }
-//
-//         // all done writing
-//         eventWriter.close();
-
-
-//         byte[] b = new byte[9];
-//         b[0] = 67;
-//         b[1] = 79;
-//         b[2] = 0;
-//         b[3] = 68;
-//         b[4] = 65;
-//         b[5] = 28;
-//         b[6] = 29;
-//         b[7] = 30;
-//         b[8] = 31;
-//
-//         try {
-//             String s = new String(b, "US-ASCII");
-//             System.out.println("My string = " + s + ", length of string = " + s.length());
-//
-//             byte[] bs = s.getBytes("US-ASCII");
-//             for (byte bb : bs){
-//                 System.out.println("b = " + bb);
-//             }
-//
-//             if (s.equals("CODA")) {
-//                 System.out.println("CO0DA = CODA");
-//             }
-//             else {
-//                 System.out.println("CO0DA != CODA");
-//             }
-//
-//             StringBuffer stringData = new StringBuffer(s);
-//             System.out.println("Buffer size = " + stringData.length());
-//
-//         }
-//         catch (UnsupportedEncodingException e) {
-//             e.printStackTrace();
-//         }
-//         System.exit(0);
-
-         // Write Big Endian file (11 ints -> 8 block header ints, 2 bank header ints, 1 data int)
-         ByteBuffer buf = ByteBuffer.allocate(4*8192);
-
-         // block header is first
-         buf.putInt(8192); // full block size
-         buf.putInt(1);  // block number
-         buf.putInt(8);  // header length
-         buf.putInt(8);  // start of next event
-         buf.putInt(60); // end of last event
-         buf.putInt(2);  // version number
-         buf.putInt(0);  // reserved
-         buf.putInt(0xc0da0100);  // magic number
-
-         //------------------------------
-         // From here on we have an event
-         //------------------------------
-
-         // bank of banks next
-         buf.putInt(51); // bank length
-         //use a tag of 11 for events--for no particular reason
-         int tag  = 11;
-         int num  = 3;
-         int type = 0x10 /* bank of banks */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-
-            // bank of banks next
-            buf.putInt(18); // bank length
-            tag  = 20;
-            num  = 2;
-            type = 0x10 /* bank of banks */;
-            buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-
-            // bank of ints next
-            buf.putInt(16); // bank length
-            tag  = 21;
-            num  = 1;
-            type = 0xb /* bank of int32s */;
-            buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         buf.putInt(0x1);
-         buf.putInt(0x2);
-         buf.putInt(0x3);
-         buf.putInt(0x4);
-         buf.putInt(0x5);
-
-         buf.putInt(0x10);
-         buf.putInt(0x20);
-         buf.putInt(0x30);
-         buf.putInt(0x40);
-         buf.putInt(0x50);
-
-         buf.putInt(0x100);
-         buf.putInt(0x200);
-         buf.putInt(0x300);
-         buf.putInt(0x400);
-         buf.putInt(0x500);
-
-            //------------------------
-
-            // bank of segments next
-            buf.putInt(3); // bank length
-            tag  = 22;
-            num  = 2;
-            type = 0xd /* bank of segments */;
-            buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-
-            // segment of ints next
-            int len = 1; // seg length
-            tag  = 23;
-            type = 0xb /* segment of ints */;
-            buf.putInt( (len & 0xffff) | ((type << 16) & 0xff0000) | (tag << 24) ); // segment header word
-            buf.putInt(0x06050403);
-
-            //------------------------
-
-            // bank of tagsegments next
-            buf.putInt(3); // bank length
-            tag  = 24;
-            num  = 2;
-            type = 0xc /* bank of tagsegments */;
-            buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-
-            // segment of ints next
-            len  = 1; // tagseg length
-            tag  = 25;
-            type = 0xb /* tagsegment of ints */;
-            buf.putInt( len & 0xffff | ((type << 16) & 0xf0000) | (tag << 20) ); // segment header word
-            buf.putInt(0x07060504);
-
-
-         // bank of ints next
-         buf.putInt(2); // bank length
-         tag  = 12;
-         num  = 2;
-         type = 0x1 /* bank of uint32s */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         buf.putInt(0x04030201);
-
-         // bank of shorts next
-         buf.putInt(4); // bank length
-         tag  = 13;
-         num  = 2;
-         type = 0x4 /* bank of shorts */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         buf.putShort((short)0x0403);
-         buf.putShort((short)0x0201);
-         buf.putShort((short)0x0001);
-         buf.putShort((short)0x0002);
-         buf.putShort((short)0x0003);
-         buf.putShort((short)0x0004);
-
-         // bank of longs next
-         buf.putInt(3); // bank length
-         tag  = 14;
-         num  = 2;
-         type = 0x9 /* bank of longs */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         buf.putLong(0x1234123412341234L);
-
-         // bank of floats next
-         buf.putInt(2); // bank length
-         tag  = 15;
-         num  = 2;
-         type = 0x2 /* bank of floats */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         buf.putFloat(1.23e-4F);
-
-         // bank of doubles next
-         buf.putInt(3); // bank length
-         //use a tag of 11 for events--for no particular reason
-         tag  = 16;
-         num  = 2;
-         type = 0x8 /* bank of doubles */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         buf.putDouble(-5.6789e-300);
-
-         // bank of strings
-         buf.putInt(3); // bank length
-         //use a tag of 11 for events--for no particular reason
-         tag  = 17;
-         num  = 2;
-         type = 0x3 /* bank of strings */;
-         buf.putInt( (num & 0xff) | ((type << 8) & 0xff00) | (tag << 16) ); // second bank header word
-         byte[] b = new byte[8];
-         b[0] = 67;
-         b[1] = 79;
-         b[2] = 68;
-         b[3] = 65;
-         b[4] = 51;
-         b[5] = 15;
-         buf.put(b);
-
-         // now, write this into a file

[truncated at 1000 lines; 207 more skipped]

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioFileTest.java
--- EvioFileTest.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,160 +0,0 @@

-package org.jlab.coda.jevio;
-
-import org.jlab.coda.jevio.EvioFile.ReadStatus;
-
-/**
- * A set of static functions that test evio files. It also has some other diagnostic methods for getting counts.
- * 
- * @author heddle
- * 
- */
-public class EvioFileTest {
-
-	/**
-	 * This enum is used for file testing. <br>
-	 * PASS indicates that a given test passed. <br>
-	 * FAIL indicates that a given test failed.
-	 */
-	public static enum TestResult {
-		PASS, FAIL
-	}
-
-	/**
-	 * Get a total count of the number of physical records.
-	 * 
-	 * @param evioFile the file to be processed.
-	 * @return the total count of blocks (physical records.)
-	 */
-	public static int totalBlockCount(EvioFile evioFile) {
-		evioFile.rewind();
-		ReadStatus status = ReadStatus.SUCCESS;
-		int count = 0;
-
-		while (status == ReadStatus.SUCCESS) {
-			status = evioFile.nextBlockHeader();
-			if (status == ReadStatus.SUCCESS) {
-				evioFile.position(evioFile.getCurrentBlockHeader().nextBufferStartingPosition());
-				count++;
-			}
-		}
-
-		System.out.println("total block count: " + count);
-
-		evioFile.rewind();
-		return count;
-	} // totalBlockCount
-
-	/**
-	 * Tests whether we can look through the file and find all the block headers.
-	 * 
-	 * @param evioFile the file to be tested.
-	 * @return the result of this test, either PASS or FAIL.
-	 */
-	public static TestResult readAllBlockHeadersTest(EvioFile evioFile) {
-		evioFile.rewind();
-		ReadStatus status = ReadStatus.SUCCESS;
-		int blockCount = 0;
-
-		while (status == ReadStatus.SUCCESS) {
-			status = evioFile.nextBlockHeader();
-			if (status == ReadStatus.SUCCESS) {
-				evioFile.position(evioFile.getCurrentBlockHeader().nextBufferStartingPosition());
-				blockCount++;
-			}
-		}
-
-		TestResult result;
-
-		// should have read to the end of the file
-		if (status == ReadStatus.END_OF_FILE) {
-			System.out.println("Total blocks read: " + blockCount);
-			result = TestResult.PASS;
-		}
-		else {
-			result = TestResult.FAIL;
-		}
-
-		System.out.println("readAllBlockHeadersTest: " + result);
-
-		evioFile.rewind();
-		return result;
-	} // readAllBlockHeadersTest
-
-	/**
-	 * Tests whether we can look through the file read all the events.
-	 * 
-	 * @param evioFile the file to be tested.
-	 * @return the result of this test, either <code>TestResult.PASS</code> or <code>TestResult.FAIL</code>.
-	 */
-	public static TestResult readAllEventsTest(EvioFile evioFile) {
-		// store current file position
-		int oldPosition = evioFile.position();
-
-		evioFile.rewind();
-		EvioEvent event;
-		int count = 0;
-		TestResult result = TestResult.PASS;
-
-		try {
-			while ((event = evioFile.nextEvent()) != null) {
-				count++;
-				BaseStructureHeader header = event.getHeader();
-
-				System.out.println(count + ")  size: " + header.getLength() + " type: " + header.getDataTypeName()
-						+ " \"" + event.getDescription() + "\"");
-			}
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-			result = TestResult.FAIL;
-		}
-
-		System.out.println("readAllBlockHeadersTest: " + result);
-
-		// restore file position
-		evioFile.position(oldPosition);
-		return result;
-	} // readAllEventsTest
-
-	/**
-	 * Tests whether we can parse events from the file.
-	 * 
-	 * @param evioFile the file to be tested.
-	 * @param num the number to parse. Will try to parse this many (unless it runs out.) Use -1 to parse all events.
-	 *            Note: if <code>num</code> is greater than the number of events in the file, it doesn't constitute an
-	 *            error.
-	 * @return the result of this test, either <code>TestResult.PASS</code> or <code>TestResult.FAIL</code>.
-	 */
-	public static TestResult parseEventsTest(EvioFile evioFile, int num) {
-		// store current file position
-		int oldPosition = evioFile.position();
-
-		if (num < 0) {
-			num = Integer.MAX_VALUE;
-		}
-
-		evioFile.rewind();
-		EvioEvent event;
-		int count = 0;
-		TestResult result = TestResult.PASS;
-
-		try {
-			while ((count < num) && ((event = evioFile.nextEvent()) != null)) {
-				evioFile.parseEvent(event);
-				count++;
-			}
-		}
-		catch (EvioException e) {
-			e.printStackTrace();
-			result = TestResult.FAIL;
-		}
-
-		System.out.println("parseEventsTest parsed: " + count + " events");
-		System.out.println("parseEventsTest result: " + result);
-
-		// restore file position
-		evioFile.position(oldPosition);
-		return result;
-	} // readAllEventsTest
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioSegment.java
--- EvioSegment.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,105 +0,0 @@

-package org.jlab.coda.jevio;
-
-import javax.xml.stream.XMLStreamWriter;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * This holds a CODA Segment structure. Mostly it has a header (a <code>SegementHeader</code>) and the raw data stored as an
- * byte array.
- * 
- * @author heddle
- * 
- */
-public class EvioSegment extends BaseStructure {
-
-	/**
-	 * The XML record tag for a segment.
-	 */
-	public static final String ELEMENT_NAME = "segment";
-
-	/**
-	 * Null constructor creates an empty SegmentHeader.
-	 * 
-	 * @see SegmentHeader
-	 */
-	public EvioSegment() {
-		this(new SegmentHeader());
-	}
-
-	/**
-	 * Constructor using a provided SegmentHeader
-	 * 
-	 * @param segmentHeader the header to use.
-	 * @see SegmentHeader
-	 */
-	public EvioSegment(SegmentHeader segmentHeader) {
-		super(segmentHeader);
-	}
-	
-	/**
-	 * This is the general constructor to use for a Segment.
-	 * @param tag the tag for the segment header.
-	 * @param dataType the (enum) data type for the content of the segment.
-	 */
-	public EvioSegment(int tag, DataType dataType) {
-		this(new SegmentHeader(tag, dataType));
-	}
-	
-	/**
-	 * This is the general constructor to use for a Segment.
-	 * @param tag the tag for the segment header.
-	 * @param dataType the (int) data type for the content of the segment.
-	 */
-	public EvioSegment(int tag, int dataType) {
-		this(new SegmentHeader(tag, dataType));
-	}
-
-	/**
-	 * This implements the abstract method from <code>BaseStructure</code>. It is a convenience method use instead of
-	 * "instanceof" to see what type of structure we have. Note: this returns the type of this structure, not the type
-	 * of data this structure holds.
-	 * 
-	 * @return the <code>StructureType</code> of this structure, which is a StructureType.SEGMENT.
-	 * @see StructureType
-	 */
-	@Override
-	public StructureType getStructureType() {
-		return StructureType.SEGMENT;
-	}
-	
-	/**
-	 * Write this segment structure out as an XML record.
-	 * @param xmlWriter the writer used to write the events.
-	 */
-	@Override
-	public void toXML(XMLStreamWriter xmlWriter) {
-
-        try {
-            commonXMLStart(xmlWriter);
-            if (DataType.getDataType(header.dataType).isStructure()) {
-                xmlWriter.writeAttribute("content", xmlContentAttributeName);
-            }
-            xmlWriter.writeAttribute("data_type", String.format("0x%x", header.dataType));
-            xmlWriter.writeAttribute("tag", "" + header.tag);
-            xmlWriter.writeAttribute("length", "" + header.length);
-            xmlWriter.writeAttribute("ndata", "" + getNumberDataItems());
-            increaseXmlIndent();
-            commonXMLDataWrite(xmlWriter);
-            decreaseXmlIndent();
-            commonXMLClose(xmlWriter);
-        }
-        catch (XMLStreamException e) {
-            e.printStackTrace();
-        }
-	}
-	
-	/**
-	 * Get the element name for the bank for writing to XML.
-	 * @return the element name for the structure for writing to XML.
-	 */
-	@Override
-	public String getXMLElementName() {
-		return ELEMENT_NAME;
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioTagSegment.java
--- EvioTagSegment.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,106 +0,0 @@

-package org.jlab.coda.jevio;
-
-import javax.xml.stream.XMLStreamWriter;
-import javax.xml.stream.XMLStreamException;
-
-/**
- * This holds a CODA TagSegment structure. Mostly it has a header (a <code>TagSegementHeader</code>) and the raw data stored as an
- * byte array.
- * 
- * @author heddle
- * 
- */
-public class EvioTagSegment extends BaseStructure {
-
-	/**
-	 * The XML record tag for a tag segment.
-	 */
-	public static final String ELEMENT_NAME = "tagsegment";
-
-
-	/**
-	 * Null constructor creates an empty TagSegmentHeader.
-	 * 
-	 * @see TagSegmentHeader
-	 */
-	public EvioTagSegment() {
-		this(new TagSegmentHeader());
-	}
-
-	/**
-	 * Constructor using a provided TagSegmentHeader
-	 * 
-	 * @param tagSegmentHeader the header to use.
-	 * @see TagSegmentHeader
-	 */
-	public EvioTagSegment(TagSegmentHeader tagSegmentHeader) {
-		super(tagSegmentHeader);
-	}
-	
-	/**
-	 * This is the general constructor to use for a TagSegment.
-	 * @param tag the tag for the tag segment header.
-	 * @param dataType the (enum) data type for the content of the tag segment.
-	 */
-	public EvioTagSegment(int tag, DataType dataType) {
-		this(new TagSegmentHeader(tag, dataType));
-	}
-	
-	/**
-	 * This is the general constructor to use for a TagSegment.
-	 * @param tag the tag for the tag segment header.
-	 * @param dataType the (int) data type for the content of the tag segment.
-	 */
-	public EvioTagSegment(int tag, int dataType) {
-		this(new TagSegmentHeader(tag, dataType));
-	}
-
-	/**
-	 * This implements the abstract method from <code>BaseStructure</code>. It is a convenience method use instead of
-	 * "instanceof" to see what type of structure we have. Note: this returns the type of this structure, not the type
-	 * of data this structure holds.
-	 * 
-	 * @return the <code>StructureType</code> of this structure, which is a StructureType.TAGSEGMENT.
-	 * @see StructureType
-	 */
-	@Override
-	public StructureType getStructureType() {
-		return StructureType.TAGSEGMENT;
-	}
-	
-	/**
-	 * Write this tag segment structure out as an XML record.
-	 * @param xmlWriter the writer used to write the events.
-	 */
-	@Override
-	public void toXML(XMLStreamWriter xmlWriter) {
-		
-        try {
-            commonXMLStart(xmlWriter);
-            if (DataType.getDataType(header.dataType).isStructure()) {
-			    xmlWriter.writeAttribute("content", xmlContentAttributeName);
-            }
-            xmlWriter.writeAttribute("data_type", String.format("0x%x", header.dataType));
-            xmlWriter.writeAttribute("tag", "" + header.tag);
-            xmlWriter.writeAttribute("length", "" + header.length);
-            xmlWriter.writeAttribute("ndata", "" + getNumberDataItems());
-            increaseXmlIndent();
-            commonXMLDataWrite(xmlWriter);
-            decreaseXmlIndent();
-            commonXMLClose(xmlWriter);
-        }
-        catch (XMLStreamException e) {
-            e.printStackTrace();
-        }
-	}
-
-	/**
-	 * Get the element name for the bank for writing to XML.
-	 * @return the element name for the structure for writing to XML.
-	 */
-	@Override
-	public String getXMLElementName() {
-		return ELEMENT_NAME;
-	}
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N EvioXMLDictionary.java
--- EvioXMLDictionary.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,221 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.ByteArrayInputStream;
-import java.util.Collections;
-import java.util.Vector;
-
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
-
-import org.w3c.dom.Document;
-import org.w3c.dom.NamedNodeMap;
-import org.w3c.dom.Node;
-import org.w3c.dom.NodeList;
-import org.xml.sax.SAXException;
-
-/**
- * This was developed to read the xml dictionary that Maurizio uses for GEMC. It implements INameProvider, just like all
- * other dictionary readers.
- * 
- * @author heddle
- * 
- */
-@SuppressWarnings("serial")
-public class EvioXMLDictionary extends Vector<EvioDictionaryEntry> implements INameProvider {
-
-	/**
-	 * There is only one type of element. This is its stange name.
-	 */
-	private static String ENTRY = "xmldumpDictEntry";
-
-	/**
-	 * The "name" attribute name.
-	 */
-	private static String NAME = "name";
-
-	/**
-	 * The "tag" attribute name.
-	 */
-	private static String TAG = "tag";
-
-	/**
-	 * The "num" attribute name.
-	 */
-	private static String NUM = "num";
-
-    /**
-     * Create an EvioXMLDictionary. This is not a standard CODA disctionary, but a format developed for use by GEMC.
-     *
-     * @param file file containing xml.
-     */
-    public EvioXMLDictionary(File file) {
-        this(getDomObject(file));
-    }
-
-    /**
-     * Create an EvioXMLDictionary. This is not a standard CODA disctionary, but a format developed for use by GEMC.
-     *
-     * @param xmlString string containing xml.
-     */
-    public EvioXMLDictionary(String xmlString) {
-        this(getDomObject(xmlString));
-    }
-
-    /**
-	 * Create an EvioXMLDictionary. This is not a standard CODA disctionary, but a format developed for use by GEMC.
-	 * 
-	 * @param domDocument DOM object representing xml dictionary.
-	 */
-	public EvioXMLDictionary(Document domDocument) {
-		super(100);
-
-		// try to get the XML dom document
-		if (domDocument != null) {
-			NodeList list = domDocument.getElementsByTagName(ENTRY);
-
-			if (list != null) {
-				for (int index = 0; index < list.getLength(); index++) {
-					Node node = list.item(index);
-					if (node != null) {
-						if (node.hasAttributes()) {
-							String name = null;
-							String tag = null;
-							String num = null;
-
-							NamedNodeMap map = node.getAttributes();
-
-							// get the name
-							Node nameNode = map.getNamedItem(NAME);
-							if (nameNode != null) {
-								name = nameNode.getNodeValue();
-							}
-
-							// get the tag
-							Node tagNode = map.getNamedItem(TAG);
-							if (tagNode != null) {
-								tag = tagNode.getNodeValue();
-							}
-
-							// get the num
-							Node numNode = map.getNamedItem(NUM);
-							if (numNode != null) {
-								num = numNode.getNodeValue();
-							}
-							
-							add (new EvioDictionaryEntry(tag, num, name));
-						} // end node has attributes
-					} // end node not null
-				} // end loop over list
-			}
-		}
-		
-		//sort
-		Collections.sort(this);
-		
-//System.out.println(this);
-
-	} // end Constructor
-
-	
-	/**
-	 * Returns the pretty name of some evio structure. Typically this is involve
-	 * the use of the "tag" and, if present, "num" fields. There may also be a hierarchical
-	 * dependence. 
-	 * 
-	 * @param structure the structure to find the name of.
-	 * @return a descriptive name, e.g., "Edep".
-	 */
-	@Override
-	public String getName(BaseStructure structure) {
-		for (EvioDictionaryEntry entry : this) {
-			if (entry.match(structure)) {
-				return entry.getDescription(); 
-			}
-		}
-		return NameProvider.NO_NAME_STRING;
-	}
-
-	/**
-	 * Return a dom object corresponding to an xml file.
-	 * 
-	 * @param file the XML File object
-	 * @return the dom object (or <code>null</code>.)
-	 */
-	private static Document getDomObject(File file) {
-		// get the factory
-		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-		Document dom = null;
-
-		try {
-
-			// Using factory get an instance of document builder
-			DocumentBuilder db = dbf.newDocumentBuilder();
-
-			// parse using builder to get DOM representation of the XML file
-			dom = db.parse(file);
-
-		}
-		catch (ParserConfigurationException e) {
-			e.printStackTrace();
-		}
-		catch (SAXException e) {
-			e.printStackTrace();
-		}
-		catch (IOException e) {
-			e.printStackTrace();
-		}
-
-		return dom;
-	}
-
-    /**
-     * Return a dom object corresponding to an xml string.
-     *
-     * @param xmlString XML string representing dictionary
-     * @return the dom object (or <code>null</code>.)
-     */
-    private static Document getDomObject(String xmlString) {
-        // get the factory
-        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-        Document dom = null;
-
-        try {
-
-            // Using factory get an instance of document builder
-            DocumentBuilder db = dbf.newDocumentBuilder();
-
-            // parse using builder to get DOM representation of the XML string
-            ByteArrayInputStream bais = new ByteArrayInputStream(xmlString.getBytes());
-            dom = db.parse(bais);
-
-        }
-        catch (ParserConfigurationException e) {
-            e.printStackTrace();
-        }
-        catch (SAXException e) {
-            e.printStackTrace();
-        }
-        catch (IOException e) {
-            e.printStackTrace();
-        }
-
-        return dom;
-    }
-
-	/**
-	 * Get a string representation of the dictionary.
-	 * @return a string representation of the dictionary.
-	 */
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(1024);
-		sb.append("-- Dictionary --\n");
-		for (EvioDictionaryEntry entry : this) {
-			sb.append(entry + "\n");
-		}
-		return sb.toString();
-	}
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N IEvioFilter.java
--- IEvioFilter.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,29 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This interface allows applications to create filters so that they only recieve certain structures
- * when events are being processed. Below is a filter that accepts any structure that has tag = 400.
- * <pre>
- * IEvioFilter myFilter = new IEvioFilter() {
- *     public boolean accept(StructureType structureType, BaseStructureHeader structureHeader) {
- *         return (structureHeader.getTag() == 400);
- *     }
- * };
- * EventParser.getInstance().setEvioFilter(myFilter);
- * </pre>
- * @author heddle
- *
- */
-public interface IEvioFilter {
-
-	/**
-	 * @param structureType the structure type, a <code>StructureType</code> enum, of the structure
-	 * that was just found, e.g., <code>StructureType.BANK</code>.
-	 * @param structureHeader the header for the structure that was just found. From this
-	 * header the tag, num, length, and data type are available, so the application can filter
-	 * based on those quantities. 
-	 * @return <code>true</code> if the structure passes the filter and should be given to the listeners.
-	 * @see StructureType
-	 */
-	public boolean accept(StructureType structureType, BaseStructureHeader structureHeader);
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N IEvioListener.java
--- IEvioListener.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,35 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.util.EventListener;
-
-/**
- * In SAX like behavior, implementors will listen for structures encountered when an event is parsed.
- * 
- * @author heddle
- * 
- */
-public interface IEvioListener extends EventListener {
-
-	/**
-	 * Called when a structure is read while parsing an event.
-	 * 
-	 * NOTE: the user should NOT modify the event or the structure.
-	 * 
-	 * @param evioEvent the data type, BANK, SEGMENT, or TAGSEGMENT
-	 * @param structure the full structure, including header
-	 */
-	public void gotStructure(EvioEvent evioEvent, IEvioStructure structure);
-    
-    /**
-     * Starting to parse a new event.
-     * @param evioEvent the event in question.
-     */
-    public void startEventParse(EvioEvent evioEvent);
-
-    /**
-     * Done parsing a new event.
-     * @param evioEvent the event in question.
-     */
-    public void endEventParse(EvioEvent evioEvent);
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N IEvioProgressListener.java
--- IEvioProgressListener.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,11 +0,0 @@

-package org.jlab.coda.jevio;
-
-public interface IEvioProgressListener {
-
-	/**
-	 * Something is listenening for progress, e.g. the number of events that has been written to XML.
-	 * @param num the current number,
-	 * @param total the total number, i.e, we have completed num out of total.
-	 */
-	public void completed(int num, int total);
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N IEvioStructure.java
--- IEvioStructure.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,103 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This interface is implemented by classes representing the basic evio structures: banks, segments, and tagsegments.
- * Note there is not "getNum" methods, because not all structures have num fields in their header, only BANKs do.
- * 
- * @author heddle
- * 
- */
-public interface IEvioStructure {
-
-	/**
-	 * Returns the header for this structure
-	 * 
-	 * @return the <code>BaseStructureHeader</code> for this structure.
-	 */
-	public BaseStructureHeader getHeader();
-
-	/**
-	 * Return the StructureType for this structure.
-	 * 
-	 * @return the StructureType for this structure.
-	 * @see StructureType
-	 */
-	public StructureType getStructureType();
-	
-	/**
-	 * Gets the raw data as an integer array, if the type as indicated by the
-	 * header is appropriate.
-	 * NOTE: since Java does not have unsigned primitives, both INT32 and UINT32 data types will be
-	 * returned as int arrays. The application will have to deal with reinterpreting signed ints that are
-	 * negative as unsigned ints
-	 * @return the data as an int array, or <code>null</code> if this makes no sense for the given type.
-	 */
-	public int[] getIntData();
-	
-	/**
-	 * Gets the raw data as a double array, if the type as indicated by the
-	 * header is appropriate.
-	 * @return the data as an double array, or <code>null</code> if this makes no sense for the given type.
-	 */
-	public double[] getDoubleData();
-	
-	/**
-	 * Gets the raw data as an byte array, if the type as indicated by the
-	 * header is appropriate.
-	 * NOTE: since Java does not have unsigned primitives, CHAR8 and UCHAR8 data types will be
-	 * returned as byte arrays. The application will have to deal with reinterpreting bytes as characters,
-	 * if necessary.
-	 * @return the data as an byte array, or <code>null</code> if this makes no sense for the given type.
-	 */
-	public byte[] getByteData();
-	
-    /**
-     * Gets the raw data as an array of String objects, if the type as indicated by the
-     * header is appropriate.
-     * @return the data as an array of String objects, or <code>null</code> if this makes no sense for the given type.
-     * (The only DataType it makes sense for is CHARSTAR8.)
-     */
-    public String[] getStringData();
-
-//    /**
-//     * Gets the raw data as a String, if the type as indicated by the
-//     * header is appropriate.
-//     * @return the data as a String, or <code>null</code> if this makes no sense for the given type.
-//     * (The only DataType it makes sense for is CHARSTAR8.)
-//     */
-//    public String getStringData();
-
-	/**
-	 * Gets the raw data as a long array, if the type as indicated by the
-	 * header is appropriate.
-	 * NOTE: since Java does not have unsigned primitives, both LONG64 and ULONG64 data types will be
-	 * returned as long arrays. The application will have to deal with reinterpreting signed longs that are
-	 * negative as unsigned longs.
-	 * @return the data as an long array, or <code>null</code> if this makes no sense for the given type.
-	 */
-	public long[] getLongData();
-	
-	/**
-	 * Gets the raw data as a float array, if the type as indicated by the
-	 * header is appropriate.
-	 * @return the data as an double array, or <code>null</code> if this makes no sense for the given type.
-	 */
-	public float[] getFloatData();
-	
-	/**
-	 * Gets the raw data as a short array, if the type as indicated by the
-	 * header is appropriate.
-	 * @return the data as an short array, or <code>null</code> if this makes no sense for the given type.
-	 */
-	public short[] getShortData();
-	
-	/**
-	 * Get the description from the name provider (dictionary), if there is one.
-	 * @return the description from the name provider (dictionary), if there is one. If not, return
-	 *         NameProvider.NO_NAME_STRING.
-	 */
-	public String getDescription();
-
-
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N IEvioWriter.java
--- IEvioWriter.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,18 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-
-/**
- * This is implemented by objects that will be writing themselve's to en evio file.
- * @author heddle
- *
- */
-public interface IEvioWriter {
-
-	/**
-	 * Write myself out a byte buffer.
-	 * @param byteBuffer the byteBuffer to write to.
-	 * @return the number of bytes written.
-	 */
-	public int write(ByteBuffer byteBuffer);
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N INameProvider.java
--- INameProvider.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,21 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This interface must be implemented by dictionary readers. For example, a dictionary reader that parses standard CODA
- * dictionary plain text files, or a dictionary reader that processes the xml dictionary Maurizio uses for GEMC.
- * 
- * @author heddle
- * 
- */
-public interface INameProvider {
-
-	/**
-	 * Returns the pretty name of some evio structure. Typically this is involve
-	 * the use of the "tag" and, if present, "num" fields. There may also be a hierarchical
-	 * dependence. 
-	 * 
-	 * @param structure the structure to find the name of.
-	 * @return a descriptive name, e.g., "Edep".
-	 */
-	public String getName(BaseStructure structure);
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N NameProvider.java
--- NameProvider.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,55 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This class maintains the single global NameProvider. There is no default name provider, so if the application doesn't
- * provide one, the static method <code>getName</code> will always return the constant <code>NO_NAME_STRING</code>,
- * which will be something like "NO_NAME_STRING".
- * 
- * Typically at start up an application will locate a dictionary file, use the <code>NameProviderFactory</code> to
- * create a <code>INameProvider</code>, and then call the static method @link #setProvider(INameProvider).
- * 
- * @author heddle
- * 
- */
-public class NameProvider {
-
-	/**
-	 * A string used to indicate that no name can be determined.
-	 */
-	public static String NO_NAME_STRING = "???";
-
-	/**
-	 * The singleton
-	 */
-	private static INameProvider provider;
-
-	/**
-	 * Private constructor prevents anyone from making one of these.
-	 */
-	private NameProvider() {
-	}
-
-	/**
-	 * Sets the one global (singleton) name provider.
-	 * 
-	 * @param aProvider the provider to use.
-	 */
-	public static void setProvider(INameProvider aProvider) {
-		provider = aProvider;
-	}
-
-	/**
-	 * Returns the pretty name of some evio structure. Typically this is involve
-	 * the use of the "tag" and, if present, "num" fields. There may also be a hierarchical
-	 * dependence. 
-	 * 
-	 * @param structure the structure to find the name of.
-	 * @return a descriptive name, e.g., "Edep".
-	 */
-	public static String getName(BaseStructure structure) {
-		if (provider == null) {
-			return NO_NAME_STRING;
-		}
-		return provider.getName(structure);
-	}
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N NameProviderFactory.java
--- NameProviderFactory.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,54 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.io.File;
-
-/**
- * A Factory class for generating an appropriate INameProvider. It makes its decisions based on the dictionary file that
- * it gets handed in its only public method, <code>createNameProvider</code>. For example, if it is given an xml file
- * (based on a ".xml" extension) it guesses that you want a reader that can handle the xml diction file developed for
- * GEMC.
- * 
- * @author heddle
- * 
- */
-public class NameProviderFactory {
-
-	/**
-	 * Creates a NameProvider based on the file name.
-	 * 
-	 * @param file dictionary file.
-	 * @return a NameProvider appropriate for the fileName.
-	 */
-	public static INameProvider createNameProvider(File file) {
-        INameProvider provider = null;
-
-        if (file != null) {
-            // only handle xml files for now
-            if (file.getName().endsWith(".xml")) {
-                return new EvioXMLDictionary(file);
-            }
-            // TODO provide provider for standard CODA dictionaries
-        }
-
-        return provider;
-    }
-
-
-    /**
-     * Creates a NameProvider based on the file name.
-     *
-     * @param xmlString xml dictionary string.
-     * @return a NameProvider appropriate for the fileName.
-     */
-    public static INameProvider createNameProvider(String xmlString) {
-        INameProvider provider = null;
-
-        if (xmlString != null) {
-            return new EvioXMLDictionary(xmlString);
-            // TODO provide provider for standard CODA dictionaries
-        }
-
-        return provider;
-    }
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N SegmentHeader.java
--- SegmentHeader.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,98 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-/**
- * This the the header for an evio segment structure (<code>EvioSegment</code>). It does not contain the raw data, just the
- * header. 
- * 
- * @author heddle
- * 
- */
-public final class SegmentHeader extends BaseStructureHeader {
-	
-	
-	/**
-	 * Null constructor.
-	 */
-	public SegmentHeader() {
-	}
-
-	/**
-	 * Constructor.
-	 * @param tag the tag for the segment header.
-	 * @param dataType the data type for the content of the segment.
-	 */
-	public SegmentHeader(int tag, DataType dataType) {
-		super(tag, dataType);
-	}
-
-	/**
-	 * Constructor.
-	 * @param tag the tag for the segment header.
-	 * @param dataType the (int) data type for the content of the segment.
-	 */
-	public SegmentHeader(int tag, int dataType) {
-		super(tag, dataType);
-	}
-
-    /**
-     * {@inheritDoc}
-     */
-    public int getHeaderLength() {return 1;}
-
-    /**
-     * {@inheritDoc}
-     */
-    protected void toArray(byte[] bArray, int offset, ByteOrder order) {
-        if (order == ByteOrder.BIG_ENDIAN) {
-            bArray[offset]   = byteValue(tag);
-            bArray[offset+1] = byteValue(dataType);
-            ByteDataTransformer.shortToBytes(shortValue(length), bArray, offset+2);
-        }
-        else {
-            ByteDataTransformer.shortToBytes(Short.reverseBytes(shortValue(length)), bArray, offset);
-            bArray[offset+2] = byteValue(dataType);
-            bArray[offset+3] = byteValue(tag);
-        }
-    }
-
-	/**
-	 * Obtain a string representation of the bank header.
-	 * 
-	 * @return a string representation of the bank header.
-	 */
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(512);
-		sb.append(String.format("segment length: %d\n", length));
-		sb.append(String.format("number:         %d\n", number));
-		sb.append(String.format("data type:      %s\n", getDataTypeName()));
-		sb.append(String.format("tag:            %d\n", tag));
-		return sb.toString();
-	}
-	
-	/**
-	 * Write myself out a byte buffer. This write is relative--i.e., it uses the current position of the buffer.
-	 * 
-	 * @param byteBuffer the byteBuffer to write to.
-	 * @return the number of bytes written, which for a SegmentHeader is 4.
-	 */
-	@Override
-	public int write(ByteBuffer byteBuffer) {
-        if (byteBuffer.order() == ByteOrder.BIG_ENDIAN) {
-            byteBuffer.put(byteValue(tag));
-            byteBuffer.put(byteValue(dataType));
-            byteBuffer.putShort(shortValue(length));
-        }
-        else {
-            byteBuffer.putShort(shortValue(length));
-            byteBuffer.put(byteValue(dataType));
-            byteBuffer.put(byteValue(tag));
-        }
-		return 4;
-	}
-
-
-}

\ No newline at end of file

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N StructureFinder.java
--- StructureFinder.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,78 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.util.List;
-
-/**
- * This is a set of convenient static methods used to find lists of structures within an event that
- * match certain criteria. For most part it uses the <code>List<BaseStructure>&nbsp;getMatchingStructures(IEvioFilter)</code> 
- * method on the provided <code>EvioEvent</code> object by constructing the appropriate filter.
- * @author heddle
- *
- */
-public class StructureFinder {
-
-	
-	/**
-	 * Collect all the structures in an event that pass a filter.
-	 * @param event the event being queried.
-	 * @param filter the filter that must be passed. If <code>null</code>, this will return all the structures.
-	 * @return a collection of all structures that are accepted by a filter for the provided event.
-	 */
-	public static List<BaseStructure> getMatchingStructures(EvioEvent event, IEvioFilter filter) {
-		if (event == null) {
-			return null;
-		}
-		return event.getMatchingStructures(filter);
-	}
-	
-	/**
-	 * Collect all the banks in an event that match a provided tag and number in their header. Only Banks are returned,
-	 * because only Banks have a number field.
-	 * @param event the event being queried.
-	 * @param tag the tag to match.
-	 * @param number the number to match.
-	 * @return a collection of all Banks that are accepted by a filter for the provided event.
-	 */
-	public static List<BaseStructure> getMatchingBanks(EvioEvent event, final int tag, final int number) {
-		IEvioFilter filter = new IEvioFilter() {
-			@Override
-			public boolean accept(StructureType type, BaseStructureHeader header) {
-				return (type == StructureType.BANK) && (tag == header.tag) && (number == header.number);
-			}
-		};
-		return getMatchingStructures(event, filter);
-	}	
-	
-	/**
-	 * Collect all the structures in an event that match a provided tag in their header.
-	 * @param event the event being queried.
-	 * @param tag the tag to match.
-	 * @return a collection of all structures that are accepted by a filter for the provided event.
-	 */
-	public static List<BaseStructure> getMatchingStructures(EvioEvent event, final int tag) {
-		IEvioFilter filter = new IEvioFilter() {
-			@Override
-			public boolean accept(StructureType type, BaseStructureHeader header) {
-				return (tag == header.tag);
-			}
-		};
-		return getMatchingStructures(event, filter);
-	}	
-
-	/**
-	 * Collect all the non-banks (i.e., Segments and TagSegments) in an event that match a provided tag in their header. No Banks are returned,
-	 * @param event the event being queried.
-	 * @param tag the tag to match.
-	 * @return a collection of all non-bank structures that are accepted by a filter for the provided event.
-	 */
-	public static List<BaseStructure> getMatchingNonBanks(EvioEvent event, final int tag) {
-		IEvioFilter filter = new IEvioFilter() {
-			@Override
-			public boolean accept(StructureType type, BaseStructureHeader header) {
-				return (type != StructureType.BANK) && (tag == header.tag);
-			}
-		};
-		return getMatchingStructures(event, filter);
-	}	
-
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N StructureType.java
--- StructureType.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,63 +0,0 @@

-package org.jlab.coda.jevio;
-
-/**
- * This an enum used to convert structure type numerical values to a more meaningful name. For example, the structure
- * type with value 0xe corresponds to the enum BANK. Mostly this is used for printing.
- * 
- * @author heddle
- * 
- */
-public enum StructureType {
-
-	UNKNOWN32(0x0), 
-	TAGSEGMENT(0xc), 
-	SEGMENT(0xd), 
-	BANK(0xe);
-
-	private int value;
-
-	private StructureType(int value) {
-		this.value = value;
-	}
-
-	/**
-	 * Get the enum's value.
-	 * 
-	 * @return the value, e.g., 0xe for a BANK
-	 */
-	public int getValue() {
-		return value;
-	}
-
-	/**
-	 * Obtain the name from the value.
-	 * 
-	 * @param value the value to match.
-	 * @return the name, or "UNKNOWN".
-	 */
-	public static String getName(int value) {
-		StructureType structuretypes[] = StructureType.values();
-		for (StructureType dt : structuretypes) {
-			if (dt.value == value) {
-				return dt.name();
-			}
-		}
-		return "UNKNOWN";
-	}
-
-	/**
-	 * Obtain the enum from the value.
-	 * 
-	 * @param value the value to match.
-	 * @return the matching enum, or <code>null</code>.
-	 */
-	public static StructureType getStructureType(int value) {
-		StructureType structuretypes[] = StructureType.values();
-		for (StructureType dt : structuretypes) {
-			if (dt.value == value) {
-				return dt;
-			}
-		}
-		return null;
-	}
-}

jevio-base/src/main/java/org/jlab/coda/jevio

diff -N TagSegmentHeader.java
--- TagSegmentHeader.java	27 Jul 2011 23:19:01 -0000	1.1.1.1
+++ /dev/null	1 Jan 1970 00:00:00 -0000
@@ -1,97 +0,0 @@

-package org.jlab.coda.jevio;
-
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-/**
- * This the the header for an evio tag segment structure (<code>EvioTagSegment</code>). It does not contain the raw data, just the
- * header. 
- * 
- * @author heddle
- * 
- */
-public final class TagSegmentHeader extends BaseStructureHeader {
-	
-	/**
-	 * Null constructor.
-	 */
-	public TagSegmentHeader() {
-	}
-
-	/**
-	 * Constructor.
-	 * @param tag the tag for the tag segment header.
-	 * @param dataType the data type for the content of the tag segment.
-	 */
-	public TagSegmentHeader(int tag, DataType dataType) {
-		super(tag, dataType);
-	}
-
-	/**
-	 * Constructor.
-	 * @param tag the tag for the tag segment header.
-	 * @param dataType the (int) data type for the content of the tag segment.
-	 */
-	public TagSegmentHeader(int tag, int dataType) {
-		super(tag, dataType);
-	}
-
-
-    /**
-     * {@inheritDoc}
-     */
-    public int getHeaderLength() {return 1;}
-
-    /**
-     * {@inheritDoc}
-     */
-    protected void toArray(byte[] bArray, int offset, ByteOrder order) {
-        short compositeWord = (short) ((tag << 4) | (dataType & 0xf));
-
-        if (order == ByteOrder.BIG_ENDIAN) {
-            ByteDataTransformer.shortToBytes(compositeWord, bArray, offset);
-            ByteDataTransformer.shortToBytes(shortValue(length), bArray, offset+2);
-        }
-        else {
-            ByteDataTransformer.shortToBytes(Short.reverseBytes(shortValue(length)), bArray, offset);
-            ByteDataTransformer.shortToBytes(Short.reverseBytes(compositeWord), bArray, offset+2);
-        }
-    }
-    
-	/**
-	 * Obtain a string representation of the bank header.
-	 * 
-	 * @return a string representation of the bank header.
-	 */
-	@Override
-	public String toString() {
-		StringBuffer sb = new StringBuffer(512);
-		sb.append(String.format("tag-seg length: %d\n", length));
-		sb.append(String.format("number:         %d\n", number));
-		sb.append(String.format("data type:      %s\n", getDataTypeName()));
-		sb.append(String.format("tag:            %d\n", tag));
-		return sb.toString();
-	}
-	
-	/**
-	 * Write myself out a byte buffer. This write is relative--i.e., it uses the current position of the buffer.
-	 * 
-	 * @param byteBuffer the byteBuffer to write to.
-	 * @return the number of bytes written, which for a TagSegmentHeader is 4.
-	 */
-	@Override
-	public int write(ByteBuffer byteBuffer) {
-		short compositeWord = (short) ((tag << 4) | (dataType & 0xf));
-
-        if (byteBuffer.order() == ByteOrder.BIG_ENDIAN) {
-            byteBuffer.putShort(compositeWord);
-            byteBuffer.putShort(shortValue(length));
-        }
-        else {
-            byteBuffer.putShort(shortValue(length));
-            byteBuffer.putShort(compositeWord);
-        }
-		return 4;
-	}
-
-}

\ No newline at end of file