FastQFile.h
/*
* Copyright (C) 2010 Regents of the University of Michigan
*
* 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, either version 3 of the License, or
* (at your option) any later version.
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef __FASTQ_VALIDATOR_H__
#define __FASTQ_VALIDATOR_H__
#include <iostream>
#include <map>
#include "StringBasics.h"
#include "InputFile.h"
#include "BaseComposition.h"
#include "FastQStatus.h"
/// Class for reading/validating a fastq file.
class FastQFile
{
public:
/// Constructor.
/// /param minReadLength The minimum length that a base sequence must be for
/// it to be valid.
/// \param numPrintableErrors The maximum number of errors that should be reported
/// in detail before suppressing the errors.
FastQFile(int minReadLength = 10, int numPrintableErrors = 20);
/// Disable messages - do not write to cout.
void disableMessages();
/// Enable messages - write to cout.
void enableMessages();
/// Disable Unique Sequence ID checking
/// (Unique Sequence ID checking is enabled by default).
void disableSeqIDCheck();
/// Enable Unique Sequence ID checking.
/// (Unique Sequence ID checking is enabled by default).
void enableSeqIDCheck();
/// Interleaved.
void interleaved();
/// Set the number of errors after which to quit reading/validating a file,
/// defaults to -1.
/// \param maxErrors # of errors before quitting,
/// -1 indicates to not quit until the entire file has been read/validated (default),
/// 0 indicates to quit without reading/validating anything.
void setMaxErrors(int maxErrors);
/// Open a FastQFile.
/// Use the specified SPACE_TYPE to determine BASE, COLOR, or UNKNOWN.
FastQStatus::Status openFile(const char* fileName,
BaseAsciiMap::SPACE_TYPE spaceType = BaseAsciiMap::UNKNOWN);
/// Close a FastQFile.
FastQStatus::Status closeFile();
/// Check to see if the file is open.
bool isOpen();
/// Check to see if the file is at the end of the file.
bool isEof();
/// Returns whether or not to keep reading the file,
/// it stops reading (false) if eof or there is a problem reading the file.
bool keepReadingFile();
/// Validate the specified fastq file
/// \param filename fastq file to be validated.
/// \param printBaseComp whether or not to print the base composition for the file.
/// true means print it, false means do not.
/// \param spaceType the spaceType to use for validation - BASE_SPACE, COLOR_SPACE,
/// or UNKNOWN (UNKNOWN means to determine the spaceType to
/// validate against from the first character of the first
/// sequence).
/// \param printQualAvg whether or not to print the quality averages for the file.
/// true means to print it, false (default) means do not.
/// \return the fastq validation status, SUCCESS on a successfully
/// validated fastq file.
FastQStatus::Status validateFastQFile(const String &filename,
bool printBaseComp,
BaseAsciiMap::SPACE_TYPE spaceType,
bool printQualAvg = false);
/// Read 1 FastQSequence, validating it.
FastQStatus::Status readFastQSequence();
///////////////////////
/// @name Public Sequence Line variables.
/// Keep public variables for a sequence's line so they can be accessed
/// without having to do string copies.
//@{
String myRawSequence;
String mySequenceIdLine;
String mySequenceIdentifier;
String myPlusLine;
String myQualityString;
//@}
/// Get the space type used for this file.
inline BaseAsciiMap::SPACE_TYPE getSpaceType()
{
return(myBaseComposition.getSpaceType());
}
private:
// Validates a single fastq sequence from myFile.
bool validateFastQSequence();
// Reads and validates the sequence identifier line of a fastq sequence.
bool validateSequenceIdentifierLine();
// Reads and validates the raw sequence line(s) and the plus line. Both are
// included in one method since it is unknown when the raw sequence line
// ends until you find the plus line that divides it from the quality
// string. Since this method will read the plus line to know when the
// raw sequence ends, it also validates that line.
bool validateRawSequenceAndPlusLines();
// Reads and validates the quality string line(s).
bool validateQualityStringLines();
// Method to validate a line that contains part of the raw sequence.
// offset specifies where in the sequence to start validating.
bool validateRawSequence(int offset);
// Method to validate the "+" line that seperates the raw sequence and the
// quality string.
bool validateSequencePlus();
// Method to validate the quality string.
// offset specifies where in the quality string to start validating.
bool validateQualityString(int offset);
// Helper method to read a line from the input file into a string.
// It also tracks the line number.
void readLine();
// Helper method for printing the contents of myErrorString. It will
// only print the errors until the maximum number of reportable errors is
// reached.
void reportErrorOnLine();
// Reset the member data for each fastq file.
void reset();
// Reset the member data for each sequence.
void resetForEachSequence();
// Log the specified message if enabled.
void logMessage(const char* message);
// Determine if it is time to quit by checking if we are to quit after a
// certain number of errors and that many errors have been encountered.
bool isTimeToQuit();
void printAvgQual();
//////////////////////////////////////////////////////////////////////
// Following member data elements are reset for each validated sequence.
//
// Buffer for storing the contents of the line read.
// Stored as member data so memory allocation is only done once.
String myLineBuffer;
// Buffer for storing the error string. This prevents the reallocation of
// the string buffer for each error.
String myErrorString;
String myTempPartialQuality;
//////////////////////////////////////////////////////////////////////
// Following member data elements are reset for each validated file.
//
IFILE myFile; // Input file to be read.
String myFileName; // Name of file being processed.
int myNumErrors; // Tracks the number of errors.
unsigned int myLineNum; // Track the line number - used for reporting errors.
BaseComposition myBaseComposition; // Tracks the base composition.
std::vector<int> myQualPerCycle; // Tracks the quality by cycle.
std::vector<int> myCountPerCycle; // Tracks the number of entries by cycle.
// Whether or not to check the sequence identifier for uniqueness.
// Checking may use up a lot of memory.
bool myCheckSeqID;
// Whether or not to check that the file is interleaved.
// Disabled by myCheckSeqID
bool myInterleaved;
// Previous sequence id for checking interleaved.
std::string myPrevSeqID;
// Map to track which identifiers have appeared in the file.
std::map<std::string, unsigned int> myIdentifierMap;
//////////////////////////////////////////////////////////////////////
// Following member data do not change for each call to the validator.
//
int myMinReadLength; // Min Length for a read.
int myNumPrintableErrors; // Max number of errors to print the details of.
// Number of errors after which to quit reading/validating a file.
// Defaults to -1.
// -1 indicates to not quit until the entire file has been read/validated.
// 0 indicates to quit without reading/validating anything.
int myMaxErrors;
// Whether or not messages should be printed.
// Defaulted to false (they should be printed).
bool myDisableMessages;
// Track if there is a problem reading the file. If there are read
// problems, stop reading the file.
bool myFileProblem;
};
#endif
InputFile.h
BaseAsciiMap::SPACE_TYPE
SPACE_TYPE
The type of space (color or base) to use in the mapping.
Definition: BaseAsciiMap.h:44
BaseAsciiMap::UNKNOWN
@ UNKNOWN
Base decision on the first raw seq character/type has yet to be determined.
Definition: BaseAsciiMap.h:47
BaseComposition
Class that tracks the composition of base by read location.
Definition: BaseComposition.h:28
BaseComposition::getSpaceType
BaseAsciiMap::SPACE_TYPE getSpaceType()
Get the space type for this composition.
Definition: BaseComposition.h:40
FastQFile
Class for reading/validating a fastq file.
Definition: FastQFile.h:30
FastQFile::interleaved
void interleaved()
Interleaved.
Definition: FastQFile.cpp:78
FastQFile::openFile
FastQStatus::Status openFile(const char *fileName, BaseAsciiMap::SPACE_TYPE spaceType=BaseAsciiMap::UNKNOWN)
Open a FastQFile.
Definition: FastQFile.cpp:92
FastQFile::enableSeqIDCheck
void enableSeqIDCheck()
Enable Unique Sequence ID checking.
Definition: FastQFile.cpp:71
FastQFile::disableMessages
void disableMessages()
Disable messages - do not write to cout.
Definition: FastQFile.cpp:49
FastQFile::isOpen
bool isOpen()
Check to see if the file is open.
Definition: FastQFile.cpp:162
FastQFile::disableSeqIDCheck
void disableSeqIDCheck()
Disable Unique Sequence ID checking (Unique Sequence ID checking is enabled by default).
Definition: FastQFile.cpp:63
FastQFile::getSpaceType
BaseAsciiMap::SPACE_TYPE getSpaceType()
Get the space type used for this file.
Definition: FastQFile.h:114
FastQFile::readFastQSequence
FastQStatus::Status readFastQSequence()
Read 1 FastQSequence, validating it.
Definition: FastQFile.cpp:309
FastQFile::closeFile
FastQStatus::Status closeFile()
Close a FastQFile.
Definition: FastQFile.cpp:134
FastQFile::validateFastQFile
FastQStatus::Status validateFastQFile(const String &filename, bool printBaseComp, BaseAsciiMap::SPACE_TYPE spaceType, bool printQualAvg=false)
Validate the specified fastq file.
Definition: FastQFile.cpp:204
FastQFile::keepReadingFile
bool keepReadingFile()
Returns whether or not to keep reading the file, it stops reading (false) if eof or there is a proble...
Definition: FastQFile.cpp:193
FastQFile::enableMessages
void enableMessages()
Enable messages - write to cout.
Definition: FastQFile.cpp:55
FastQFile::setMaxErrors
void setMaxErrors(int maxErrors)
Set the number of errors after which to quit reading/validating a file, defaults to -1.
Definition: FastQFile.cpp:85
FastQFile::FastQFile
FastQFile(int minReadLength=10, int numPrintableErrors=20)
Constructor.
Definition: FastQFile.cpp:30
FastQFile::isEof
bool isEof()
Check to see if the file is at the end of the file.
Definition: FastQFile.cpp:177
FastQStatus::Status
Status
Return value enum for the FastQFile class methods, indicating success or error codes.
Definition: FastQStatus.h:31
InputFile
Class for easily reading/writing files without having to worry about file type (uncompressed,...
Definition: InputFile.h:37
String
Definition: StringBasics.h:39