// This directory contains several small tools that I use often in my different
// C++ applications.

// Assertion.hpp
Contains the Assert<T> class for runtime error checking.  It's just syntactic
sugar.  Assuming you have a class called FileError, Assert can be used
as:  Assert<FileError>(thingToAssert, "some error message");  thingToAssert is
a boolean expression; when false, Assert throws an object of type FileError and
passes "some error message" to FileError's constructor.  Therefore, Assert<T>
assumes certain properties about T - mostly that it can be constructed with a
string argument.  See Exception<T> below.

// ByLine.hpp
A class inheriting from std::string, and overloading its >> operator.  ByLine
allows reading input files a line at a time rather than stopping at any
whitespace as std::string does.

// Conversion.hpp, Conversion.template
Syntactic sugar that is quite inefficient relative to C's atoi, atol, atof, etc.
But, for low traffic code, makes a nice conversion between numeric items and
strings:
string myNumericString = convert<string>(76.4);
double myDouble = convert<double>("53.2");

// Exception.hpp
Meant to work with Assert<T>.  Quickly define exceptions that only differ
by an integer:
typedef Exception<1> FileError;
typedef Exception<2> InputError;
later...
Assert<InputError>(argc == 3, "Wrong # of inputs");
Assert<FileError>(myFileHandle, "Could not open file");

// SingletonType.hpp
A simple template for making singletons out of any default-constructible class.
ErrorLog* errorLog = SingletonType<ErrorLog>::Instance();
Most useful when you make ErrorLog's default constructor private and make
SingletonType<ErrorLog> a friend of the ErrorLog class, but not a requirement.

// StandardFiles.hpp
A collection of standard C++ headers.  Not all are there, but will be added when
needed.

// Typify.hpp
Two lightweight structures that work well with function overloading or typifying
integers.
Int2Type<1> is a different class than Int2Type<2>
Type2Type< std::map<std::string, std::vector<std::string> > > is lighter weight
than std::map<std::string, std::vector<std::string> >.  Ahhh...use typedefs with
the STL.  typedef std::vector<std::string> VecStr;
          typedef std::map<std::string, VecStr> MapType;
          typedef Type2Type<MapType> MyType;



/* Other items */

//=========
// MSS.hpp
//=========
MSS.h contains an implementation of a linear time algorithm for finding all
 maximal scoring subsequences.  It is an implementation of the design
 outlined in:

   "A Linear Time Algorithm for Finding All Maximal Scoring Subsequences"

 by Walter L. Ruzzo and Martin Tompa, Seventh International Conference on
 Intelligent Systems for Molecular Biology, Heidelberg, Germany, August 1999,
 pp. 234-241.
