//=====================================================================
// File: FeatureList.java
// Class: FeatureList
// Package: AFLPcore
//
// Author: James J. Benham
// Date: August 10, 1998
// Contact: james_benham@hmc.edu
//
// Genographer v1.6 - Computer assisted scoring of gels.
// Changes Copyright (C) 2001 James J. Benham
// Copyright (C) 1998 Montana State University
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; version 2
// of the License.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// The GNU General Public License is distributed in the file GPL
//=====================================================================
package AFLPcore;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.util.Calendar;
import java.awt.Frame;
/**
* This is a static class that provides a list of all of the features in
* the program. This is done so that features can be added to the program
* without much effort. For example, a dialog that wants to display a list
* of scoring functions for bins should query this class to get the list.
* This way, a new scoring function can be added to the program by simply
* modifying this class. The class contains several different types of
* managers for different operations, see the manager descriptions for
* details on the types of operation supported by each. Features can
* be added by either directly modifying the class, or by extending it,
* overriding the createManagerType
calling the super
* and then adding the new feature. One should make sure that the default is
* set.
*
*
New managers could be added, but the program will not have support * for these managers, so the program would have to be modified too. * *
One possible enhancement to this class would be adding methods to scan
* directories for class files and adding them to the manager. This would
* mean that new features could be added without recompiling the program.
* However, this may be difficult if not impossible.
*
* Note: many other classes rely on this class to retrieve various components.
* For example, an import filter may query this class to see which sizing functions are
* available.
*
* @see ImportMgr
* @see ScoreManager
* @see PeakMgr
* @see CutoffMgr
* @see StandardMgr
* @see AnalysisMgr
* @see Mgr
*
* @author James J. Benham
* @version 1.6.0
* @date September 3, 2001
*/
public class FeatureList
{
private static String STANDARD_FILE = "standards.cfg";
private static String OPERATION_FILE = "doc/operation.html";
private static ImportMgr importMgr;
private static boolean createdImportMgr = false;
private static ScoreManager scoreMgr;
private static boolean createdScoreMgr = false;
private static PeakMgr peakMgr;
private static boolean createdPeakMgr = false;
private static CutoffMgr cutoffMgr;
private static boolean createdCutoffMgr = false;
private static SizeMgr sizeMgr;
private static boolean createdSizeMgr = false;
private static AnalysisMgr analysisMgr;
private static boolean createdAnalysisMgr = false;
private static StandardMgr standardMgr;
private static boolean createdStandardMgr = false;
private static GelOpMgr gelOpMgr;
private static boolean createdGelOpMgr = false;
private static LaneOpMgr laneOpMgr;
private static boolean createdLaneOpMgr = false;
private static BinOpMgr binOpMgr;
private static boolean createdBinOpMgr = false;
/**
* Gives a manager that contains all of the import filters known to the
* program.
*
* @see ImportMgr
* @see ImportFilter
*/
public static ImportMgr getImportMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdImportMgr)
{
importMgr = createImportMgr();
createdImportMgr = true;
}
return importMgr;
}
/**
* Gives a manager that contains all of the scoring methods known to the
* program.
*
* @see ScoreManager
* @see ScoreFunction
*/
public static ScoreManager getScoreMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdScoreMgr) {
scoreMgr = createScoreMgr();
createdScoreMgr = true;
}
return scoreMgr;
}
/**
* Gives a manager that contains all of the peak locating algorithms known
* to the program.
*
* @see PeakMgr
* @see PeakLocate
*/
public static PeakMgr getPeakMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdPeakMgr) {
peakMgr = createPeakMgr();
createdPeakMgr = true;
}
return peakMgr;
}
/**
* Gives a manager that contains all of the cutoff functions known to the
* program.
*
* @see CutoffMgr
* @see CutoffFunction
*/
public static CutoffMgr getCutoffMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdCutoffMgr)
{
cutoffMgr = createCutoffMgr();
createdCutoffMgr = true;
}
return cutoffMgr;
}
/**
* Gives a manager that contains all of the functions used to size a lane
* known to the program.
*
* @see SizeMgr
* @see SizeFunction
*/
public static SizeMgr getSizeMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdSizeMgr)
{
sizeMgr = createSizeMgr();
createdSizeMgr = true;
}
return sizeMgr;
}
/**
* Gives a manager that contains all of the functions used to analyize
* a gel known to the program.
*
* @see AnalysisMgr
* @see AnalysisOp
*/
public static AnalysisMgr getAnalysisMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdAnalysisMgr)
{
analysisMgr = createAnalysisMgr();
createdAnalysisMgr = true;
}
return analysisMgr;
}
/**
* Gives a manager that contains all of the operations on a gel known
* to the program.
*
* @see GelOpMgr
* @see GelOperation
*/
public static GelOpMgr getGelOpMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdGelOpMgr)
{
gelOpMgr = createGelOpMgr();
createdGelOpMgr = true;
}
return gelOpMgr;
}
/**
* Gives a manager that contains all of the operations on lanes
* known to the program.
*
* @see LaneOpMgr
* @see LaneOperation
*/
public static LaneOpMgr getLaneOpMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdLaneOpMgr)
{
laneOpMgr = createLaneOpMgr();
createdLaneOpMgr = true;
}
return laneOpMgr;
}
/**
* Gives a manager that contains all of the operations on bins
* known to the program.
*
* @see BinOpMgr
* @see BinOperation
*/
public static BinOpMgr getBinOpMgr()
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdBinOpMgr)
{
binOpMgr = createBinOpMgr();
createdBinOpMgr = true;
}
return binOpMgr;
}
/**
* Gives a manager that contains all of the size standard definitions
* known to the program.
*
* @exception IOException occurs if a problem is encountered when
* reading from the file that contains the definitions.
*
* @see StandardMgr
* @see SizeStandard
*/
public static StandardMgr getStandardMgr() throws IOException
{
// This will be executed once every session to initialize the manager.
// This is not placed in a constructor since this is a static class
// which does not have a constructor.
if(!createdStandardMgr)
{
standardMgr = createStandardMgr();
createdStandardMgr = true;
}
return standardMgr;
}
/**
* Gives a manager that contains all of the filters used to import files.
* Additional file formats can be supported be adding filters here.
* This method needs only be called once each time the program is run, and
* will be run automatically be the getImportMgr
method
* when neccessary.
*
* @return the list of filters
*/
private static ImportMgr createImportMgr()
{
ImportFilter newFilter;
// create the manager
ImportMgr mgr = new ImportMgr();
// create and add the filters
newFilter = new ABILaneFilter();
mgr.add(newFilter.getName(), newFilter);
mgr.setDefault(newFilter.getName()); // set default, but add it first
newFilter = new ABI3x00Filter();
mgr.add(newFilter.getName(), newFilter);
newFilter = new SCFFilter();
mgr.add(newFilter.getName(), newFilter);
// Add a filter for CEQ files. 09/15/00 B. Master
newFilter = new CEQLaneFilter();
mgr.add(newFilter.getName(), newFilter);
return mgr;
}
/**
* Gives a manager that contains all of the methods used to score
* a bin. This method needs only be called once each time the program is
* run, and will be called automatically by getScoreMgr
when
* neccessary.
*
* @return a container for all of the bin scoring functions.
*/
private static ScoreManager createScoreMgr()
{
ScoreFunction newScore;
// create the manager
ScoreManager mgr = new ScoreManager();
// create and add the functions
newScore = new SegregatingScore();
mgr.add(newScore.getName(), newScore);
mgr.setDefault(newScore.getName()); // set default, but add it first
return mgr;
}
/**
* Gives a manager that contains all of the functions used to define
* a cutoff. This method needs only be called once each time the program is
* run, and will be called automatically by getCutoffMgr
when
* neccessary.
*
* @return a container for all of the bin scoring functions.
*/
private static CutoffMgr createCutoffMgr()
{
CutoffFunction newCutoff;
// create the manager
CutoffMgr mgr = new CutoffMgr();
// create and add the functions
newCutoff = new LinearCutoff();
mgr.add(newCutoff.getName(), newCutoff);
mgr.setDefault(newCutoff.getName()); // set default, do after add
return mgr;
}
/**
* Gives a manager that contains all of the peak locating algorithms.
* This method needs only be called once each time the program is
* run, and will be called automatically by getPeakMgr
when
* neccessary.
*
* @return a container for all of the bin scoring functions.
*/
private static PeakMgr createPeakMgr()
{
PeakLocate newPeak;
// create the manager
PeakMgr mgr = new PeakMgr();
// create and add the location algorithms
newPeak = new HighestPeakLocate();
mgr.add(newPeak.getName(), newPeak);
mgr.setDefault(newPeak.getName()); // set default, but add it first
return mgr;
}
/**
* Gives a manager that contains all of the functions used to size a
* lane. This method needs only be called once each time the program is
* run, and will be called automatically by getAnalysisMgr
when
* neccessary.
*
* @return a container for all of the sizing functions.
*/
private static SizeMgr createSizeMgr()
{
SizeFunction newSize;
// create the manager
SizeMgr mgr = new SizeMgr();
// create and add the functions
newSize = new LocalSouthern();
mgr.add(newSize.getName(), newSize);
mgr.setDefault(newSize.getName()); // set default, do after add
newSize = new NoSize();
mgr.add(newSize.getName(), newSize);
return mgr;
}
/**
* Gives a manager that contains all of the functions used to analyize a
* gel. This method needs only be called once each time the program is
* run, and will be called automatically by getAnalysisMgr
when
* neccessary.
*
* @return a container for all of the analysis functions
*/
private static AnalysisMgr createAnalysisMgr()
{
AnalysisOp newAnalysis;
// create the manager
AnalysisMgr mgr = new AnalysisMgr();
// create and add the functions
newAnalysis = new BinAnalysis();
mgr.add(newAnalysis.getName(), newAnalysis);
mgr.setDefault(newAnalysis.getName()); // set default, do after add
newAnalysis = new MapMakerAnalysis();
mgr.add(newAnalysis.getName(), newAnalysis);
return mgr;
}
/**
* Gives a manager that contains all of the operations on a gel
* This method needs only be called once each time the program is
* run, and will be called automatically by getGelOpMgr
when
* neccessary.
*
* @return a container for all of the gel operations
*/
private static GelOpMgr createGelOpMgr()
{
GelOperation newGelOp;
// create the manager
GelOpMgr mgr = new GelOpMgr();
// create and add the functions
// ex:
// newGelOp = new ClassThatExtendsGelOperation;
// mgr.add(newGelOp.getName(), newGelOp);
//
// set the default using:
// mgr.setDefault(newGelOp.getName());
newGelOp = new SignalNorm();
mgr.add(newGelOp.getName(), newGelOp);
newGelOp = new PartialSigNorm();
mgr.add(newGelOp.getName(), newGelOp);
newGelOp = new RawView();
mgr.add(newGelOp.getName(), newGelOp);
// default is not set
return mgr;
}
/**
* Gives a manager that contains all of the operations on a lane
* This method needs only be called once each time the program is
* run, and will be called automatically by getLaneOpMgr
when
* neccessary.
*
* @return a container for all of the lane operations
*/
private static LaneOpMgr createLaneOpMgr()
{
LaneOperation newLaneOp;
// create the manager
LaneOpMgr mgr = new LaneOpMgr();
// create and add the functions
// ex:
// newLaneOp = new ClassThatExtendsLaneOperation;
// mgr.add(newLaneOp.getName(), newLaneOp);
//
// set the default using:
// mgr.setDefault(newLaneOp.getName());
// default is not set
return mgr;
}
/**
* Gives a manager that contains all of the operations on a bin
* This method needs only be called once each time the program is
* run, and will be called automatically by getBinOpMgr
when
* neccessary.
*
* @return a container for all of the bin operations
*/
private static BinOpMgr createBinOpMgr()
{
BinOperation newBinOp;
// create the manager
BinOpMgr mgr = new BinOpMgr();
// create and add the functions
// ex:
// newBinOp = new ClassThatExtendsBinOperation;
// mgr.add(newBinOp.getName(), newBinOp);
//
// set the default using:
// mgr.setDefault(newBinOp.getName());
// default is not set
return mgr;
}
/**
* Gives a manager that contains all of the size standard defintions.
* This method needs only be called once each time the program is
* run, and will be called automatically by getPeakMgr
when
* neccessary.
*
* @return a container for all of the size standard defintions.
*
* @exception IOException occurs when an error is encountered accessing
* or reading the file.
*/
private static StandardMgr createStandardMgr() throws IOException
{
SizeStandard newStandard;
// create the manager
StandardMgr mgr = new StandardMgr();
// read in the definitions from the file
BufferedReader in = new BufferedReader(new FileReader(ProgOptions.homePath
+ STANDARD_FILE));
Double size;
String line = nextLine(in);
while(line != null)
{
// the first line should be the name
newStandard = new SizeStandard(line);
// now read in the values
line = nextLine(in);
while( (line != null) && (!line.equals("-1")))
{
try
{
size = new Double(line);
}
catch(NumberFormatException e)
{
throw new IOException("Could not read number " + line);
}
newStandard.add(size.doubleValue());
line = nextLine(in);
}
// see if we ended on null, if so we ended the file before we should
// have.
if(line == null)
throw new IOException("End of file reached before standard list "+
"terminated with -1.");
// move past the -1
line = nextLine(in);
// add the standard to the manager
mgr.add(newStandard.getName(), newStandard);
}
in.close();
// No default is set. Be careful!
return mgr;
}
/**
* Gets a line from the specified input stream. It will skip over blank
* lines and lines beginning with a '#'. Additionally, white space will
* be trimmed from both ends of the string.
*
* @param inStream the stream to read from
*
* @return the line that isn't blank or a comment. null
* will be returned if the end of the stream is reached.
*
* @exception IOException if an I/O problem occurs.
*/
public static String nextLine(BufferedReader inStream) throws IOException
{
char firstCh = 'a';
String line;
do
{
line = inStream.readLine();
if(line != null)
{
line.trim();
if(line.length() >= 1)
firstCh = line.charAt(0);
}
// repeat if not the end and the line is blank or a comment
} while( (line != null) && ((line.length() == 0) || (firstCh == '#')));
return line;
}
public static void generateFileList() throws IOException
{
FileWriter fWriter = new FileWriter(ProgOptions.homePath + OPERATION_FILE);
PrintWriter out = new PrintWriter(new BufferedWriter(fWriter));
out.println("");
out.println("
Contents | "); out.println("" + "About the Program | "); out.println("
Contents | "); out.println("" + "About the Program | "); out.println("