/* $Log$ Revision 1.2 2003/05/02 07:58:45 heto Changed the package structure from se.prevas.arexis.XYZ to se.arexis.agdb.XYZ Modified configuration and source files according to package change. Revision 1.1.1.1 2002/10/16 18:14:07 heto Import of aGDB 1.5 L3 from Prevas CVS-tree. This version of aGDB is migrated to Tomcat from JServ by Tobias Hermansson Revision 1.1 2001/04/24 09:34:20 frob Moved file import classes to new package se.prevas.arexis.util.FileImport, caused updates in several files. Revision 1.2 2001/04/24 06:31:48 frob Checkin after merging frob_fileparser branch. Revision 1.1.2.2 2001/04/19 09:50:35 frob Renamed Parse() method to parseInputFile() and made the method protected. Revision 1.1.2.1 2001/04/03 10:31:06 frob Class created, replaces MappingFileParser. */ package org.tgdb.fileimport; import java.util.*; /** * The class parses a UnifiedMarkerMapping file. Such a file contains any * number of mapping sections. Each section contains a unified marker * containing a number of unified alleles. Each section may also contain * any number of markers which are mapped to the unified marker. * * <P>The class expects an input file with the following format: * * <P><PRE> * otn/ftn/1/; * MAPPING;SU1;SU2;SUn * UMark;Mark1;Mark2;MarkN * UA1;A1;A1;An * UA2;A3;A2;An * UAn;A3;A5;An * MAPPING;SU1;SU2;SU3;SU4;SUn * </PRE> * * <P>The first row is the header row, handled bu the super class. The * second row is the "MAPPING" row which indicates a new mapping * section. The first column of this row must contain the reserved word * "MAPPING". The other columns contains the sampling unit names that are * mapped in this section. The next row is the "marker row". The first column * holds the name of the unified marker. The other columns holds the * names of the markers mapped to the unified mapper. There must be as * many markers as there are sampling units. Then follows any number of * allele rows. The first column of such a row holds a unified allele. The * other columns holds an allele in a unified marker. There must be as many * alleles as there are markers. * * <P>The example above tells us that sampling unit SU2 has a marker named * Mark2. Allele A1 of that marker is mapped to the unified allele * UA1, while allele A2 of thatmarker is mapped to the unified allele UA2. * * <P>The preferred way of accessing the data in the object is by access a * given MappingSection by using <I>mappingSection()</I>. For backward * compatibility, the method <I>asMapper()</I> will return the contents of * the file as an array of Mapper objects. * * @author frob * @see AbstractFileParser */ public class MapFileParser extends MugenFileParser { /** * The mapping sections found in the file */ private Vector mMappingSections; private ArrayList mapSections; ////////////////////////////////////////////////////////////////////// // // Constructors // ////////////////////////////////////////////////////////////////////// /** * Creates a MapFileParser. * * @param fileName The name of the file to read data from * @exception AssertionException If class could not be constructed. */ public MapFileParser(String fileName) throws AssertionException, InputDataFileException { super(fileName); mMappingSections = new Vector(); mapSections = new ArrayList(); } ////////////////////////////////////////////////////////////////////// // // Public section // ////////////////////////////////////////////////////////////////////// /** * Returns the number of mapping sections in the file * * @return The number of mapping sections. */ public int mappingSections() { return mMappingSections.size(); } /** * Returns the mapping section with the given index * * @param index The index of the mapping section to return * @return A MappingSection object */ public MappingSection mappingSection(int index) { return (MappingSection) mMappingSections.elementAt(index); } public MapSection getMapSection(int index) { return (MapSection) mapSections.get(index); } public int getNumberOfMapSections() { return mapSections.size(); } /** * Prints all the mapping sections found in the file * */ public void test() { for (int i = 0; i < mappingSections(); i++) { mappingSection(i).print(); } } /** * Prints all the mapping sections found in the file using the Mapping * structure. * */ public void testAsMapper() { Mapper aMap; // The current Mapper object String[] aAlleles; // The alleles of the current Mapper String[] aUAlleles; // The unified alleles of the current // Mapper // Get the Mapper objects Mapper[] aMappers = asMapper(); // Loop all Mappers for (int i = 0; i < aMappers.length; i++) { // For each Mapper, print its sampling unit, marker and unified // marker. aMap = aMappers[i]; System.out.println("SU: " + aMap.getSUName() + " Marker: " + aMap.getMarker() + " UMarker: " + aMap.getUMarker()); // Get the alleles and unified alleles of the Mapper object and // print them aAlleles = aMap.getAlleles(); aUAlleles = aMap.getUAlleles(); for (int x = 0; x < aAlleles.length; x++) { System.out.println(aUAlleles[x] + " " + aAlleles[x]); } } } /** * Returns the contenst of the file in the form of array Mapper * objects. Each mapped marker found in the file is represented as one * Mapper object within the array. This method is for backward * compatibility. Mapper class should preferrable be removed. * * @return An array with Mapper objects */ public Mapper[] asMapper() { int aMappedMarkerCount = 0; // The total number of mapped markers // Loop all mapping sections and count the total number of mapped // markers for (int i = 0; i < mappingSections(); i++) { aMappedMarkerCount += mappingSection(i).mappedMarkers(); } // Create the array for the Mapper objects. Should have the same size // as there are mapped markers. Mapper[] aAllMappers = new Mapper[aMappedMarkerCount]; int aResultPos = 0; // The position in the result array to put // the next Mapper object in Mapper[] aSectionAsMapper;// The contents of a MappingSection // represented as Mapper objects // Loop all mapping sections found in the file for (int aIndex = 0; aIndex < mappingSections(); aIndex++) { // Get the Mapper representations of the mapped markers within the // current section. aSectionAsMapper = mappingSection(aIndex).asMapper(); // For each Mapping object in the section, add it to the result // array for (int aMappingIndex = 0; aMappingIndex < aSectionAsMapper.length; aMappingIndex++) { aAllMappers[aResultPos++] = aSectionAsMapper[aMappingIndex]; } } return aAllMappers; } private boolean isDataRow(String aRow, int aRowIndex) { return true; } ////////////////////////////////////////////////////////////////////// // // Protected section // ////////////////////////////////////////////////////////////////////// private String getValue(int col, int row) { int index = dataRows[row]; return mValues[index][col]; } /** * Update the index keeping track of the actual data rows in file. * The comments are not included. */ protected void updateDataRowsIndex() { ArrayList arr = new ArrayList(); for (int i=1;i<getFileRows();i++) { if (isDataRow(mValues[i])) arr.add(new Integer(i)); } // Initialize the new array dataRows = new int[arr.size()]; for (int i=0;i<arr.size();i++) { dataRows[i] = ((Integer)arr.get(i)).intValue(); } } private String[] getDataRow(int row) { int index = dataRows[row]; return mValues[index]; } public void Parse() throws InputDataFileException { super.Parse(); init(); } private void init() { boolean first = true; ArrayList secArr = new ArrayList(); for (int i=0;i<getNumberOfDataRows();i++) { String[] tmp = getDataRow(i); if (tmp[0].equals("MAPPING") && first) { first=false; secArr.add(tmp); } else if (tmp[0].equals("MAPPING") && !first) { MapSection map = new MapSection(secArr); mapSections.add(map); secArr = new ArrayList(); secArr.add(tmp); } else secArr.add(tmp); } MapSection map = new MapSection(secArr); mapSections.add(map); } // /** // * Parses the data read from file. Builds a MappingSection object with // * related markers for each mapping section found in the file // * // * @exception InputDataFileException If anything wrong with the input file. // */ // protected void parseInputFile() // throws InputDataFileException // { // try // { // // // Run the inherited parse() method to read all rows of the // // file. Also parses the header section // super.parseInputFile(); // // // // // // boolean first = true; // ArrayList secArr = new ArrayList(); // // for (int i=0;i<getNumberOfDataRows();i++) // { // String[] tmp = getDataRow(i); // // if (tmp[0].equals("MAPPING") && first) // { // first=false; // } // else if (tmp[0].equals("MAPPING") && !first) // { // MapSection map = new MapSection(secArr); // mapSections.add(map); // // secArr = new ArrayList(); // // } // // // secArr.add(tmp); // // } // // // // // // // // // // // // // // // // // // // // // //// // Init variables used in loop below //// String aRow = ""; //// MappingSection aMappingSection = null; //// //// // Loop all rows read from file //// for (int aRowIndex = 0; aRowIndex < getFileRows(); aRowIndex++) //// { //// // Get a row and ensure it is a data row //// aRow = getFileData(aRowIndex); //// //// if (isDataRow(aRow, aRowIndex)) //// { //// // If row is at least 7 chars and contains "MAPPING", it is //// // the first row of a mapping section //// if (aRow.length() >= 7 && //// aRow.substring(0,7).equalsIgnoreCase("MAPPING")) //// { //// // Create a new mapping object and add it to the //// // collection of mappingSections //// //// Character delimiter = new Character(getDelimiter().charAt(0)); //// //// aMappingSection = new MappingSection(aRow, delimiter); //// addMappingSection(aMappingSection); //// //// // Increase row index and parse the next row to get the //// // marker names //// aRowIndex++; //// aMappingSection.parseMarkerRow(getFileData(aRowIndex), //// aRowIndex + 1); //// } //// //// // This is not the mapping row, parse alleles //// else //// { //// aMappingSection.parseAlleleRow(aRow, aRowIndex + 1); //// } //// } //// } // } // //catch (AssertionException e) // catch (Exception e) // { // throw new InputDataFileException(e.getMessage()); // } // // } ////////////////////////////////////////////////////////////////////// // // Private section // ////////////////////////////////////////////////////////////////////// /** * Adds a new mapping section to the collection. * * @param newMappingSection The mapping section to add. */ private void addMappingSection(MappingSection newMappingSection) { mMappingSections.add(newMappingSection); } }