Replaced cout with printf for speed in bedFile.h

	Working on maskFastaFromBed, permuteBed and addFlanksBed

src/fastaFromBed/fastaFromBed.cpp

@@ -60,15 +60,12 @@ void Bed2Fa::ExtractDNA() {
 	
 	while (getline(faDb,fastaDbLine)) {
 		
-		if (fastaDbLine.find(">chr",0) != 0 ) {
+		if (fastaDbLine.find(">",0) != 0 ) {
 			currDNA += fastaDbLine;
 		}
 		else {
 			if (currDNA.size() > 0) {
 
-				// retive the vecvtor of BED elements that come from the current 
-				// chromosome that we are processing in the fasta "database".
-						
 				vector<BED> bedList = bed->bedMapNoBin[currChrom];
 
 				// loop through each BED entry for this chrom and 
@@ -95,9 +92,6 @@ void Bed2Fa::ExtractDNA() {
 	
 	// process the last chromosome in the fasta file.
 	if (currDNA.size() > 0) {
-
-		// retrieve the vector of BED elements that come from the current 
-		// chromosome that we are processing in the fasta "database".
 		
 		vector<BED> bedList = bed->bedMapNoBin[currChrom];
 

src/intersectBed/Makefile~

+CXX = g++
+CXXFLAGS = -O2  -Wall
+LDFLAGS = 
+
+UTILITIES_DIR = ../utils/
+OBJ_DIR = ../../obj/
+BIN_DIR = ../../bin/
+
+# -------------------
+# define our includes
+# -------------------
+INCLUDES = -I$(UTILITIES_DIR)/bedFile/ -I$(UTILITIES_DIR)/lineFileUtilities/ -I$(UTILITIES_DIR)/version/
+
+# ----------------------------------
+# define our source and object files
+# ----------------------------------
+SOURCES= intersectMain.cpp intersectBed.cpp
+OBJECTS= $(SOURCES:.cpp=.o)
+_EXT_OBJECTS=bedFile.o lineFileUtilities.o
+EXT_OBJECTS=$(patsubst %,$(OBJ_DIR)/%,$(_EXT_OBJECTS))
+BUILT_OBJECTS= $(patsubst %,$(OBJ_DIR)/%,$(OBJECTS))
+PROGRAM= intersectBed
+LIBS=
+
+all: $(PROGRAM)
+
+.PHONY: all
+
+$(PROGRAM): $(BUILT_OBJECTS) $(EXT_OBJECTS)
+	@echo "  * linking $(PROGRAM)"
+	@$(CXX) $(LDFLAGS) $(CXXFLAGS) -o $(BIN_DIR)/$@ $^ $(LIBS)
+
+$(BUILT_OBJECTS): $(SOURCES)
+	@echo "  * compiling" $(*F).cpp
+	@$(CXX) -c -o $@ $(*F).cpp $(LDFLAGS) $(CXXFLAGS) $(INCLUDES)
+
+$(EXT_OBJECTS):
+	@$(MAKE) --no-print-directory -C $(UTILITIES_DIR)/bedFile/
+	@$(MAKE) --no-print-directory -C $(UTILITIES_DIR)/lineFileUtilities/
+	
+clean:
+	@echo "Cleaning up."
+	@rm -f $(OBJ_DIR)/* $(BIN_DIR)/*
+
+.PHONY: clean

src/intersectBed/intersectBed.cpp

@@ -55,7 +55,7 @@ void BedIntersect::FindOverlaps(BED &a, vector<BED> &hits) {
 		printable = false;
 	}
 	
-	for (vector<BED>::iterator h = hits.begin(); h != hits.end(); ++h) {
+	for (vector<BED>::const_iterator h = hits.begin(); h != hits.end(); ++h) {
 	
 		// if forcing strandedness, move on if the hit
 		// is not on the same strand as A.
@@ -78,20 +78,20 @@ void BedIntersect::FindOverlaps(BED &a, vector<BED> &hits) {
 				
 					if (!writeB && printable) {
 						if (writeA) {
-							bedA->reportBed(a); cout << endl;
+							bedA->reportBedNewLine(a);
 						}
 						else {
-							bedA->reportBedRange(a,s,e);  cout << endl;
+							bedA->reportBedRangeNewLine(a,s,e);
 						}
 					}
 					else if (printable) {
 						if (writeA) {
-							bedA->reportBed(a); cout << "\t";
-							bedB->reportBed(*h); cout << endl;
+							bedA->reportBedTab(a);
+							bedB->reportBedNewLine(*h);
 						}
 						else {
-							bedA->reportBedRange(a,s,e); cout << "\t";
-							bedB->reportBed(*h); cout << endl;										
+							bedA->reportBedRangeTab(a,s,e);
+							bedB->reportBedNewLine(*h);									
 						}
 					}
 				}
@@ -105,20 +105,20 @@ void BedIntersect::FindOverlaps(BED &a, vector<BED> &hits) {
 					
 						if (!writeB && printable) {
 							if (writeA) {
-								bedA->reportBed(a); cout << endl;
+								bedA->reportBedNewLine(a);
 							}
 							else {
-								bedA->reportBedRange(a,s,e);  cout << endl;
+								bedA->reportBedRangeNewLine(a,s,e);
 							}
 						}
 						else if (printable) {
 							if (writeA) {
-								bedA->reportBed(a); cout << "\t";
-								bedB->reportBed(*h); cout << endl;
+								bedA->reportBedTab(a);
+								bedB->reportBedNewLine(*h);
 							}
 							else {
-								bedA->reportBedRange(a,s,e); cout << "\t";
-								bedB->reportBed(*h); cout << endl;										
+								bedA->reportBedRangeTab(a,s,e);
+								bedB->reportBedNewLine(*h);									
 							}
 						}
 					}
@@ -127,13 +127,14 @@ void BedIntersect::FindOverlaps(BED &a, vector<BED> &hits) {
 		}
 	}
 	if (anyHit && (numOverlaps >= 1)) {
-		bedA->reportBed(a); cout << endl;
+		bedA->reportBedNewLine(a);
 	}
 	else if (writeCount) {
-		bedA->reportBed(a); cout << "\t" << numOverlaps << endl;
+		bedA->reportBedTab(a); 
+		printf("%d\n", numOverlaps);
 	}
 	else if (noHit && (numOverlaps == 0)) {
-		bedA->reportBed(a); cout << endl;
+		bedA->reportBedNewLine(a);
 	}
 }
 
@@ -148,7 +149,13 @@ void BedIntersect::IntersectBed() {
 	string bedLine;
 	BED bedEntry;                                                                                                                        
 	int lineNum = 0;
-
+	vector<BED> hits;					// vector or potential hits
+	vector<string> bedFields;	// vector for a BED entry
+	
+	// reserve some space
+	hits.reserve(100);
+	bedFields.reserve(6);	
+	
 	// are we dealing with a file?
 	if (bedA->bedFile != "stdin") {
 
@@ -163,20 +170,30 @@ void BedIntersect::IntersectBed() {
 		// process each entry in A
 		while (getline(bed, bedLine)) {
 	
-			if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
-				continue;
-			}
-			else {			
-				// split the current line into ditinct fields
-				vector<string> bedFields;
+			lineNum++;
+			
+			if (lineNum > 1) {
 				Tokenize(bedLine,bedFields);
 
-				lineNum++;
-			
 				// find the overlaps with B if it's a valid BED entry. 
 				if (bedA->parseBedLine(a, bedFields, lineNum)) {
-					vector<BED> hits;
 					FindOverlaps(a, hits);
+					hits.clear();
+				}
+				bedFields.clear();
+			}
+			else {
+				if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
+					continue;
+				}
+				else {
+					Tokenize(bedLine,bedFields);
+					// find the overlaps with B if it's a valid BED entry. 
+					if (bedA->parseBedLine(a, bedFields, lineNum)) {
+						FindOverlaps(a, hits);
+						hits.clear();
+					}
+					bedFields.clear();
 				}
 			}
 		}
@@ -188,20 +205,30 @@ void BedIntersect::IntersectBed() {
 		// process each entry in A
 		while (getline(cin, bedLine)) {
 
-			if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
-				continue;
-			}
-			else {			
-				// split the current line into distinct fields
-				vector<string> bedFields;
+			lineNum++;
+			
+			if (lineNum > 1) {
 				Tokenize(bedLine,bedFields);
 
-				lineNum++;
-			
 				// find the overlaps with B if it's a valid BED entry. 
 				if (bedA->parseBedLine(a, bedFields, lineNum)) {
-					vector<BED> hits;
 					FindOverlaps(a, hits);
+					hits.clear();
+				}
+				bedFields.clear();
+			}
+			else {
+				if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
+					continue;
+				}
+				else {
+					Tokenize(bedLine,bedFields);
+					// find the overlaps with B if it's a valid BED entry. 
+					if (bedA->parseBedLine(a, bedFields, lineNum)) {
+						FindOverlaps(a, hits);
+						hits.clear();
+					}
+					bedFields.clear();
 				}
 			}
 		}

src/maskFastaFromBed/Makefile

+CXX = g++
+CXXFLAGS = -O3  -Wall
+LDFLAGS = 
+
+UTILITIES_DIR = ../utils/
+OBJ_DIR = ../../obj/
+BIN_DIR = ../../bin/
+
+# -------------------
+# define our includes
+# -------------------
+INCLUDES = -I$(UTILITIES_DIR)/bedFile/ -I$(UTILITIES_DIR)/sequenceUtilities/ -I$(UTILITIES_DIR)/lineFileUtilities/ -I$(UTILITIES_DIR)/version/
+
+# ----------------------------------
+# define our source and object files
+# ----------------------------------
+SOURCES= maskFastaFromBedMain.cpp maskFastaFromBed.cpp
+OBJECTS= $(SOURCES:.cpp=.o)
+_EXT_OBJECTS=bedFile.o sequenceUtils.o lineFileUtilities.o
+EXT_OBJECTS=$(patsubst %,$(OBJ_DIR)/%,$(_EXT_OBJECTS))
+BUILT_OBJECTS= $(patsubst %,$(OBJ_DIR)/%,$(OBJECTS))
+PROGRAM= maskFastaFromBed
+LIBS=
+
+all: $(PROGRAM)
+
+.PHONY: all
+
+$(PROGRAM): $(BUILT_OBJECTS) $(EXT_OBJECTS)
+	@echo "  * linking $(PROGRAM)"
+	@$(CXX) $(LDFLAGS) $(CXXFLAGS) -o $(BIN_DIR)/$@ $^ $(LIBS)
+
+$(BUILT_OBJECTS): $(SOURCES)
+	@echo "  * compiling" $(*F).cpp
+	@$(CXX) -c -o $@ $(*F).cpp $(LDFLAGS) $(CXXFLAGS) $(INCLUDES)
+
+$(EXT_OBJECTS):
+	@$(MAKE) --no-print-directory -C $(UTILITIES_DIR)/sequenceUtilities/
+	@$(MAKE) --no-print-directory -C $(UTILITIES_DIR)/lineFileUtilities/
+	@$(MAKE) --no-print-directory -C $(UTILITIES_DIR)/bedFile/
+	
+clean:
+	@echo "Cleaning up."
+	@rm -f $(OBJ_DIR)/* $(BIN_DIR)/*
+
+.PHONY: clean
\ No newline at end of file

src/maskFastaFromBed/maskFastaFromBed.cpp

+// 
+//  maskFastaFromBed.cpp
+//  BEDTools
+//  
+//  Created by Aaron Quinlan Spring 2009.
+//  Copyright 2009 Aaron Quinlan. All rights reserved.
+//
+//  Summary:  Mask fasta sequences based on BED intervals.
+//
+#include "lineFileUtilities.h"
+#include "maskFastaFromBed.h"
+
+MaskFastaFromBed::MaskFastaFromBed(string &fastaInFile, string &bedFile, string &fastaOutFile, bool &softMask) {
+
+	this->softMask = false;
+	if (softMask) {
+		this->softMask = true;
+	}
+	
+	this->fastaInFile = fastaInFile;
+	this->bedFile = bedFile;
+	this->fastaOutFile = fastaOutFile;
+	
+	this->bed = new BedFile(this->bedFile);
+	bed->loadBedFileIntoMapNoBin();
+}
+
+
+MaskFastaFromBed::~MaskFastaFromBed(void) {
+}
+
+
+//******************************************************************************
+// Mask the Fasta file based on the coordinates in the BED file.
+//******************************************************************************
+void MaskFastaFromBed::MaskFasta() {
+
+	/* Make sure that we can open all of the files successfully*/
+	
+	// open the fasta database for reading
+	ifstream fa(this->fastaInFile.c_str(), ios::in);
+	if ( !fa ) {
+		cerr << "Error: The requested fasta file (" << this->fastaInFile << ") could not be opened. Exiting!" << endl;
+		exit (1);
+	}
+	
+	// open the fasta database for reading
+	ofstream faOut(this->fastaOutFile.c_str(), ios::out);
+	if ( !faOut ) {
+		cerr << "Error: The requested fasta output file (" << this->fastaOutFile << ") could not be opened. Exiting!" << endl;
+		exit (1);
+	}	
+	
+
+	/* Read the fastaDb chromosome by chromosome*/
+	
+	string fastaInLine;
+	string currChrom;
+	string currDNA = "";
+	currDNA.reserve(500000000);
+	
+	while (getline(fa,fastaInLine)) {
+		
+		if (fastaInLine.find(">",0) != 0 ) {
+			currDNA += fastaDbLine;
+		}
+		else {
+			if (currDNA.size() > 0) {
+
+				vector<BED> bedList = bed->bedMapNoBin[currChrom];
+
+				// loop through each BED entry for this chrom and 
+				// mask the requested sequence in the FASTA file.
+				for (unsigned int i = 0; i < bedList.size(); i++) {
+					if (this->softMask) {
+						//currDNA.replace(bedList[i].start, ((bedList[i].end - bedList[i].start)));
+					}
+					else {
+						//currDNA.replace(bedList[i].start, ((bedList[i].end - bedList[i].start)));
+					}
+				}
+				faOut << ">" << currChrom << endl << currDna << endl;
+			}
+			currChrom = fastaInLine.substr(1, fastaInLine.find_first_of(" ")-1);
+			currDNA = "";
+		}
+	}
+	
+	// process the last chromosome.
+	if (currDNA.size() > 0) {
+
+		vector<BED> bedList = bed->bedMapNoBin[currChrom];
+
+		// loop through each BED entry for this chrom and 
+		// mask the requested sequence in the FASTA file.
+		for (unsigned int i = 0; i < bedList.size(); i++) {
+			if (this->softMask) {
+				currDNA.replace(bedList[i].start, ((bedList[i].end - bedList[i].start)));
+			}
+			else {
+				currDNA.replace(bedList[i].start, ((bedList[i].end - bedList[i].start)));
+			}
+		}
+		faOut << ">" << currChrom << endl << currDna << endl;
+	}
+}
+

src/maskFastaFromBed/maskFastaFromBed.h

+#ifndef MASKFASTAFROMBED_H
+#define MASKFASTAFROMBED_H
+
+#include "bedFile.h"
+#include "sequenceUtils.h"
+#include <vector>
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+//************************************************
+// Class methods and elements
+//************************************************
+class MaskFastaFromBed {
+
+public:
+	
+	// constructor 
+	MaskFastaFromBed(string &, string &, string &, bool &);
+
+	// destructor
+	~MaskFastaFromBed(void);
+
+	void MaskFasta();
+	
+private:
+	
+	bool softMask;
+	
+	string fastaInFile;
+	string bedFile;
+	string fastaOutFile;
+	
+	// instance of a bed file class.
+	BedFile *bed;
+
+};
+
+#endif /* MASKFASTAFROMBED */

src/maskFastaFromBed/maskFastaFromBedMain.cpp

+#include "maskFastaFromBed.h"
+#include "version.h"
+
+using namespace std;
+
+// define our program name
+#define PROGRAM_NAME "maskFastaFromBed"
+
+
+// define our parameter checking macro
+#define PARAMETER_CHECK(param, paramLen, actualLen) (strncmp(argv[i], param, min(actualLen, paramLen))== 0) && (actualLen == paramLen)
+
+// function declarations
+void ShowHelp(void);
+
+int main(int argc, char* argv[]) {
+
+	// our configuration variables
+	bool showHelp = false;
+
+	// input files
+	string fastaInFile;
+	string bedFile;
+
+	// output files
+	string fastaOutFile;
+
+	// checks for existence of parameters
+	bool haveFastaIn = false;
+	bool haveBed = false;
+	bool haveFastaOut = false;
+	bool softMask = false;
+
+	// check to see if we should print out some help
+	if(argc <= 1) showHelp = true;
+
+	for(int i = 1; i < argc; i++) {
+		int parameterLength = (int)strlen(argv[i]);
+
+		if((PARAMETER_CHECK("-h", 2, parameterLength)) || 
+		(PARAMETER_CHECK("--help", 5, parameterLength))) {
+			showHelp = true;
+		}
+	}
+
+	if(showHelp) ShowHelp();
+
+	// do some parsing (all of these parameters require 2 strings)
+	for(int i = 1; i < argc; i++) {
+
+		int parameterLength = (int)strlen(argv[i]);
+
+		if(PARAMETER_CHECK("-in", 3, parameterLength)) {
+			haveFastaIn = true;
+			fastaInFile = argv[i + 1];
+			i++;
+		} 
+		else if(PARAMETER_CHECK("-out", 4, parameterLength)) {
+			haveFastaOut = true;
+			fastaOutFile = argv[i + 1];
+			i++;
+		} 
+		else if(PARAMETER_CHECK("-bed", 4, parameterLength)) {
+			haveBed = true;
+			bedFile = argv[i + 1];
+			i++;
+		}
+		else if(PARAMETER_CHECK("-soft", 5, parameterLength)) {
+			softMask = true;
+			i++;
+		}	
+		else {
+			cerr << "*****ERROR: Unrecognized parameter: " << argv[i] << " *****" << endl << endl;
+			showHelp = true;
+		}		
+	}
+
+	if (!haveFastaIn || !haveFastaOut || !haveBed) {
+		showHelp = true;
+	}
+	
+	if (!showHelp) {
+
+		MaskFastaFromBed *maskFasta = new MaskFastaFromBed(fastaInFile, bedFile, fastaOutFile, softMask);
+		maskFasta->MaskFasta(); 
+		return 0;
+	}
+	else {
+		ShowHelp();
+	}
+}
+
+void ShowHelp(void) {
+	
+	cerr << "===============================================" << endl;
+	cerr << " " <<PROGRAM_NAME << " v" << VERSION << endl ;
+	cerr << " Aaron Quinlan, Ph.D. (aaronquinlan@gmail.com)  " << endl ;
+	cerr << " Hall Laboratory, University of Virginia" << endl;
+	cerr << "===============================================" << endl << endl;
+	cerr << "Description: Mask a fasta file based on BED coordinates." << endl << endl;
+
+	cerr << "Usage: " << PROGRAM_NAME << " -in -out -bed (-soft)" << endl << endl;
+
+	cerr << "Input Files:" << endl;
+	cerr << "  -in   <FASTA input file>          " << endl;
+	cerr << "  -bed  <BED coordinates file>          " << endl;
+
+	cerr << "Output Files:" << endl;
+	cerr << "  -out <FASTA output file>                           " << endl;
+
+	cerr << "Options:" << endl;
+	cerr << "  -soft  Enforce \"soft\" masking.  That is, instead of masking with Ns, mask with lower-case bases." << endl;
+	
+	cerr << "\nHelp:" << endl;
+	cerr << "  -h                             shows this help text" << endl;
+	
+	cerr << "NOTES: " << endl;
+	cerr << "\t***Only tab-delimited BED3 - BED6 formats allowed.***"<< endl << endl;
+
+	// end the program here
+	exit(1);
+	
+}

src/utils/bedFile/bedFile.cpp

@@ -63,11 +63,12 @@ static int getBin(int start, int end)
 	* and for each chromosome (which is assumed to be less than
 	* 512M.)  A range goes into the smallest bin it will fit in. */
 {
-	int startBin = start, endBin = end-1, i;
+	int startBin = start;
+	int endBin = end-1;
 	startBin >>= _binFirstShift;
 	endBin >>= _binFirstShift;
 	
-	for (i=0; i<6; ++i) {
+	for (int i=0; i<6; ++i) {
 		if (startBin == endBin) {
 			return binOffsetsExtended[i] + startBin;
 		}
@@ -142,15 +143,14 @@ bool byChromThenStart(BED const & a, BED const & b){
 void BedFile::binKeeperFind(map<int, vector<BED>, std::less<int> > &bk, const int start, const int end, vector<BED> &hits) {
 
 	int startBin, endBin;
-	int i,j;
-
-	startBin = (start>>_binFirstShift);
-	endBin = ((end-1)>>_binFirstShift);
-	for (i=0; i<6; ++i) {
+	startBin = (start >>_binFirstShift);
+	endBin = ((end-1) >>_binFirstShift);
+	
+	for (int i = 0; i < 6; ++i) {
 		int offset = binOffsetsExtended[i];
 
-		for (j = (startBin+offset); j <= (endBin+offset); ++j)  {
-			for (vector<BED>::iterator el = bk[j].begin(); el != bk[j].end(); ++el) {
+		for (int j = (startBin+offset); j <= (endBin+offset); ++j)  {
+			for (vector<BED>::const_iterator el = bk[j].begin(); el != bk[j].end(); ++el) {
 				
 				if (overlaps(el->start, el->end, start, end) > 0) {
 					hits.push_back(*el);
@@ -210,7 +210,7 @@ BedFile::~BedFile(void) {
 }
 
 
-bool BedFile::parseBedLine (BED &bed, const vector<string> &lineVector, const int &lineNum) {
+bool BedFile::parseBedLine (BED &bed, const vector<string> &lineVector, int lineNum) {
 
 	if ( (lineNum > 1) && (lineVector.size() == this->bedType)) {
 
@@ -350,13 +350,11 @@ void BedFile::loadBedFileIntoMap() {
 	bedFields.reserve(6);		// reserve space for worst case (BED 6)
 
 	while (getline(bed, bedLine)) {
+		lineNum++;
+		
+		if (lineNum > 1) {
 
-		if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
-			continue;
-		}
-		else {
 			Tokenize(bedLine,bedFields);
-			lineNum++;
 
 			if (parseBedLine(bedEntry, bedFields, lineNum)) {
 				int bin = getBin(bedEntry.start, bedEntry.end);
@@ -366,6 +364,22 @@ void BedFile::loadBedFileIntoMap() {
 			}
 			bedFields.clear();
 		}
+		else {
+			if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
+				continue;
+			}
+			else {
+				Tokenize(bedLine,bedFields);
+
+				if (parseBedLine(bedEntry, bedFields, lineNum)) {
+					int bin = getBin(bedEntry.start, bedEntry.end);
+					bedEntry.count = 0;
+					bedEntry.minOverlapStart = INT_MAX;
+					this->bedMap[bedEntry.chrom][bin].push_back(bedEntry);	
+				}
+				bedFields.clear();
+			}
+		}
 	}
 }
 
@@ -439,54 +453,109 @@ void BedFile::loadBedFileIntoMapNoBin() {
 
 
 /*
-	reportBed
+	reportBedTab
 	
-	Writes the _original_ BED entry.
+	Writes the _original_ BED entry with a TAB
+	at the end of the line.
 	Works for BED3 - BED6.
 */
-void BedFile::reportBed(const BED &bed) {
+void BedFile::reportBedTab(BED bed) {
 	
 	if (this->bedType == 3) {
-		cout << bed.chrom << "\t" << bed.start << "\t" << bed.end;
+		printf ("%s\t%d\t%d\t", bed.chrom.c_str(), bed.start, bed.end);
 	}
 	else if (this->bedType == 4) {
-		cout << bed.chrom << "\t" << bed.start << "\t" << bed.end << "\t"
-		<< bed.name;
+		printf ("%s\t%d\t%d\t%s\t", bed.chrom.c_str(), bed.start, bed.end, bed.name.c_str());
 	}
 	else if (this->bedType == 5) {
-		cout << bed.chrom << "\t" << bed.start << "\t" << bed.end << "\t"
-		<< bed.name << "\t" << bed.score;
+		printf ("%s\t%d\t%d\t%s\t%s\t", bed.chrom.c_str(), bed.start, bed.end, bed.name.c_str(), 
+										bed.score.c_str());
 	}
 	else if (this->bedType == 6) {
-		cout << bed.chrom << "\t" << bed.start << "\t" << bed.end << "\t" 
-		<< bed.name << "\t" << bed.score << "\t" << bed.strand;
+		printf ("%s\t%d\t%d\t%s\t%s\t%s\t", bed.chrom.c_str(), bed.start, bed.end, bed.name.c_str(), 
+											bed.score.c_str(), bed.strand.c_str());
 	}
 }
 
 
+
 /*
-	reportBedRange
+	reportBedNewLine
 	
-	Writes a custom start->end for a BED entry.
+	Writes the _original_ BED entry with a NEWLINE
+	at the end of the line.
 	Works for BED3 - BED6.
 */
-void BedFile::reportBedRange(const BED &bed, int &start, int &end) {
+void BedFile::reportBedNewLine(BED bed) {
+	
+	if (this->bedType == 3) {
+		printf ("%s\t%d\t%d\n", bed.chrom.c_str(), bed.start, bed.end);
+	}
+	else if (this->bedType == 4) {
+		printf ("%s\t%d\t%d\t%s\n", bed.chrom.c_str(), bed.start, bed.end, bed.name.c_str());
+	}
+	else if (this->bedType == 5) {
+		printf ("%s\t%d\t%d\t%s\t%s\n", bed.chrom.c_str(), bed.start, bed.end, bed.name.c_str(), 
+										bed.score.c_str());
+	}
+	else if (this->bedType == 6) {
+		printf ("%s\t%d\t%d\t%s\t%s\t%s\n", bed.chrom.c_str(), bed.start, bed.end, bed.name.c_str(), 
+											bed.score.c_str(), bed.strand.c_str());
+	}
+}
+
+
+
+/*
+	reportBedRangeNewLine
+	
+	Writes a custom start->end for a BED entry
+	with a NEWLINE at the end of the line.
+
+	Works for BED3 - BED6.
+*/
+void BedFile::reportBedRangeTab(BED bed, int start, int end) {
 
 	if (this->bedType == 3) {
-		cout << bed.chrom << "\t" << start << "\t" << end;
+		printf ("%s\t%d\t%d\t", bed.chrom.c_str(), start, end);
 	}
 	else if (this->bedType == 4) {
-		cout << bed.chrom << "\t" << start << "\t" << end << "\t"
-		<< bed.name;
+		printf ("%s\t%d\t%d\t%s\t", bed.chrom.c_str(), start, end, bed.name.c_str());
 	}
 	else if (this->bedType == 5) {
-		cout << bed.chrom << "\t" << start << "\t" << end << "\t"
-		<< bed.name << "\t" << bed.score;
+		printf ("%s\t%d\t%d\t%s\t%s\t", bed.chrom.c_str(), start, end, bed.name.c_str(), 
+										bed.score.c_str());
 	}
 	else if (this->bedType == 6) {
-		cout << bed.chrom << "\t" << start << "\t" << end << "\t" 
-		<< bed.name << "\t" << bed.score << "\t" << bed.strand;
+		printf ("%s\t%d\t%d\t%s\t%s\t%s\t", bed.chrom.c_str(), start, end, bed.name.c_str(), 
+											bed.score.c_str(), bed.strand.c_str());
 	}
 }
 
 
+
+/*
+	reportBedRangeTab
+	
+	Writes a custom start->end for a BED entry 
+	with a TAB at the end of the line.
+	
+	Works for BED3 - BED6.
+*/
+void BedFile::reportBedRangeNewLine(BED bed, int start, int end) {
+
+	if (this->bedType == 3) {
+		printf ("%s\t%d\t%d\n", bed.chrom.c_str(), start, end);
+	}
+	else if (this->bedType == 4) {
+		printf ("%s\t%d\t%d\t%s\n", bed.chrom.c_str(), start, end, bed.name.c_str());
+	}
+	else if (this->bedType == 5) {
+		printf ("%s\t%d\t%d\t%s\t%s\n", bed.chrom.c_str(), start, end, bed.name.c_str(), 
+										bed.score.c_str());
+	}
+	else if (this->bedType == 6) {
+		printf ("%s\t%d\t%d\t%s\t%s\t%s\n", bed.chrom.c_str(), start, end, bed.name.c_str(), 
+											bed.score.c_str(), bed.strand.c_str());
+	}
+}
\ No newline at end of file

src/utils/bedFile/bedFile.h

@@ -10,6 +10,7 @@
 #include <cstring>
 #include <algorithm>
 #include <limits.h>
+#include <cstdio>
 
 using namespace std;
 
@@ -101,7 +102,7 @@ public:
 	~BedFile(void);
 
 	// Methods
-	bool parseBedLine (BED &, const vector<string> &, const int &);
+	bool parseBedLine (BED &, const vector<string> &, int);
 
 	void loadBedFileIntoMap();
 	void loadBedFileIntoMapNoBin();	
@@ -111,9 +112,14 @@ public:
 		const int, vector<BED> &);
 
 	void countHits(map<int, vector<BED>, std::less<int> > &, BED &, bool &);
-	void reportBed(const BED &);
-	void reportBedRange(const BED &, int &, int &);
 
+	// printing methods
+	void reportBedTab(BED);
+	void reportBedNewLine(BED);
+		
+	void reportBedRangeTab(BED, int, int);
+	void reportBedRangeNewLine(BED, int, int);
+	
 	// a vector of the BED entries in the BED file.
 	vector<BED> bedVector;
 	masterBedMap bedMap;

src/utils/lineFileUtilities/lineFileUtilities.cpp

@@ -17,19 +17,6 @@
 void Tokenize(const string& str, vector<string>& tokens)
 {
 
-/*
-	string::size_type start = 0;
-	string::size_type end = 0;
-
-	cout << str << endl; 
-	while ((start = str.find_first_not_of(" ", start)) != string::npos) {
-	    end = str.find_first_of(" ", start);
-		cout << start << ":" << end << endl;
-	    tokens.push_back(str.substr(start, end - start));
-	    start = end;
-	  }
-*/
-
 	// Skip delimiters at beginning.
 	string::size_type lastPos = str.find_first_not_of("\t", 0);
 	// Find first "non-delimiter".
@@ -44,7 +31,6 @@ void Tokenize(const string& str, vector<string>& tokens)
 		// Find next "non-delimiter"
 		pos = str.find_first_of("\t", lastPos);
 	}
-
 }