/* BaitFisher (version 1.2.8) a program for designing DNA target enrichment baits * Copyright 2013-2016 by Christoph Mayer * * This source file is part of the BaitFisher-package. * * 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 BaitFisher. If not, see . * * * For any enquiries send an Email to Christoph Mayer * c.mayer.zfmk@uni-bonn.de * * When publishing work that is based on the results please cite: * Mayer et al. 2016: BaitFisher: A software package for multi-species target DNA enrichment probe design * */ #ifndef CFILE_H #define CFILE_H #include #include #include "../faststring2.h" // Should not exceed 1 000 000 without making sure that the stack is large enough. #ifndef BUFFERSIZE #define BUFFERSIZE 1000000 #endif #define UNDOs 1 // Changes: // 22.08.2009: Added getline function for faststring. Disadvantage: additional dependence on faststring.h // 07.01.2011: Changed Version to CFile2_1.h // 07.01.2011: Now uses the faststring2.h // Idea: ios:: set Buffer size // TODO: Old mac format not supported. // This requires to allow two successive calls to the internal ungetchar command. class CFile : private std::ifstream { private: // There is a problem here: The stack size is limited. One should consider to move this to the heap. // allocate it with malloc, new or declare it as static - the latter is not good in a class since a // static class member is the same for all instances of the class, which we do not want here. char buffer[BUFFERSIZE]; char* buffer_end; char* buffer_pos; char __status; unsigned __line; // bool __eof; // bool __openFailed; unsigned fill_buffer(unsigned overlap) { unsigned good_overlap = buffer_end - buffer; std::streamsize n; if (good_overlap < overlap) { overlap = good_overlap; } if (overlap > 0) std::memmove(buffer, buffer_end - overlap, overlap); std::ifstream::read(buffer + overlap, BUFFERSIZE - overlap); n = std::ifstream::gcount(); if ( n == 0 ) { __status |= __eof_flag; // Set eof flag __status &= ~__good_flag; // Unset good flag __status |= __fail_flag; // Setting the fail flag is not always correct. Needs to be unset in routines that read more than one char. } buffer_pos = buffer+overlap; buffer_end = buffer_pos + n; return overlap; } char getchar_intern() // should only be done if we did not fail yet!!!! This would allow us to recover!!! { if ( buffer_pos == buffer_end ) { fill_buffer(UNDOs); if (__status & __fail_flag) return '\0'; } return *buffer_pos++; } void ungetchar_intern() // should only be done if we did not fail yet!!!! This would allow us to recover!!! { if (buffer_pos != buffer) --buffer_pos; else { __status |= __fail_flag; // Set fail flag. __status &= ~__good_flag; // Unset good flag. } } public: enum {__eof_flag = 1, __good_flag = 2, __fail_flag = 4, __bad_flag = 8, __fail_reason1 = 16, __fail_reason2 = 32, __fail_reason3 = 64, __fail_reason4 = 128}; void open(const char *name) { ffopen(name); } void open(std::string name) { ffopen(name); } void ffopen(const char *name) { __status = __good_flag; std::ifstream::open(name); if ( std::ifstream::fail() ) { __status |= __fail_flag; // Set fail flag. __status &= ~__good_flag; // Unset good flag. } __line = 1; buffer_end = buffer; buffer_pos = buffer; } void ffopen(std::string name) { ffopen(name.c_str()); } void ffclose() { std::ifstream::close(); } void close() { ffclose(); } bool exists() // -- deprecated -- do not use this any more - check fail() instead !!!!!!!! { return !fail(); } bool fail() { return (__status & __fail_flag); } bool good() { return (__status & __good_flag); } unsigned line() { return __line; } bool eof() { return (__status & __eof_flag); } char status() { return __status; } bool fail_reason1() { return (__status & __fail_reason1); } bool fail_reason2() { return (__status & __fail_reason2); } bool fail_reason3() { return (__status & __fail_reason3); } bool fail_reason4() { return (__status & __fail_reason4); } void rewind() { clear(); std::ifstream::seekg (0, std::ios::beg); // clear(); } void clear(char s = __good_flag) { __status = s; std::ifstream::clear(); } void ungetchar() { if (*(buffer_pos-1) == '\n' && !(__status & __fail_flag)) --__line; ungetchar_intern(); } void ignore(int delim = -1) { while (__status == __good_flag && getchar() != delim ){} } char peekchar() { char c = getchar(); ungetchar(); return c; } char peek() { return peekchar(); } char getchar() { register char c; c = getchar_intern(); if ( c < 14 && !(__status & __fail_flag) ) { if ( c == '\r' ) { // Overwrite the last reading position that contained the \r with \n *(buffer_pos-1) = '\n'; // Should always be valid! Works for 1 Undo c = getchar_intern(); if ( c != '\n' && !(__status & __fail_flag) ) { // std::cerr << "Old mac file format currently not supported." << std::endl; ungetchar(); /* old mac format, else dos format */ } c = '\n'; ++__line; } else if ( c == '\n') ++__line; } return c; } char getrawchar() { return getchar_intern(); } void getline(faststring& str, char delim='\n') { char c = getchar(); str.clear(); while ( c != delim && !(__status & __fail_flag) ) { str.push_back(c); c = getchar(); } if ((__status & __fail_flag) && str.size() > 0) __status &= ~__fail_flag; // Unset fail flag by using & on the complement of the fail flag; } void getline(std::string& str, char delim='\n') { char c = getchar(); str=""; while ( c != delim && !(__status & __fail_flag) ) { str.push_back(c); c = getchar(); } if ((__status & __fail_flag) && str.size() > 0) __status &= ~__fail_flag; // Unset fail flag by using & on the complement of the fail flag; } void getline(char* cstr, unsigned n, char delim='\n') { char c = getchar(); unsigned i = 0; while ( !(__status & __fail_flag ) && i < n-1 && c != delim) { cstr[i] = c; ++i; c = getchar(); } if ((__status & __fail_flag) && i > 0) __status &= ~__fail_flag; // Unset fail flag by using & on the complement of the fail flag; cstr[i] = '\0'; } void readFileIntoString(faststring &str) { char c; str.clear(); c = getchar(); while (!(__status & __fail_flag)) { str.push_back(c); c = getchar(); } } char lastchar() { char c; if ( buffer_pos != buffer_end ) c = *(buffer_pos-1); else { __status |= __fail_flag; // Set fail flag. __status &= ~__good_flag; // Unset good flag. return 0; } /* It could be a '\r' in mac format */ if (c == '\r') c = '\n'; return c; } char lastrawchar() { char c; if ( buffer_pos != buffer_end ) c = *(buffer_pos-1); else { __status |= __fail_flag; // Set fail flag. __status &= ~__good_flag; // Unset good flag. return 0; } return c; } }; #endif