/* BaitFisher (version 1.2.7) 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 GFF_RECORD_H #define GFF_RECORD_H #include "easystring.h" #include #include "range_functions.h" #include "cstdio" // for FILE #include "CSequence_Mol2_1.h" //*********************************************************************************** // In the long run, we intend to follow the conventions specified in: http://www.bioperl.org/wiki/GFF3 // In particular the handling of special characters does not conform to this standard yet. // Convention: fstart and fend are the direct gff field entries 4 and 5. Minimum value is 1. The end value is the last position in the feature. // This convention is not identical to the convention in CgenomeFeature class, where all values are 0 based. // In this class the philisoph is to be as close as possible to the value in the file. // Example: First three bases of seq.: 1,3 // // Convention has been checked. //*********************************************************************************** using namespace std; static const easystring empty_easy_string; // Forward declaration of friend functions of the classes in this file. This avoids the friend-injection problem: class GFF_record; bool position_lessThan_GFF_record(GFF_record &, GFF_record &); bool position_lessThan_GFF_record_pointer(GFF_record *, GFF_record *); class GFF_record { private: easystring parse_error; easystring seqname; // gff field 1 easystring source; // gff field 2 easystring feature; // gff field 3 unsigned fstart; // gff field 4 unsigned fend; // gff field 5 // According to the gff file conventions this is an inclusive end. easystring score; // gff field 6 char strand; // gff field 7 char phase; // gff field 8 std::vector att_names; std::vector att_names_lower_case; std::vector att_values; public: GFF_record (const std::string &str) { parse_string(str); } GFF_record (const easystring &str) { parse_string(str); } GFF_record (easystring &p_seqname, easystring &p_source, easystring &p_feature, unsigned p_fstart, unsigned p_fend, easystring &p_score, char p_strand, char p_phase, easystring &p_att ): seqname(p_seqname), source(p_source), feature(p_feature), fstart(p_fstart), fend(p_fend), score(p_score), strand(p_strand), phase(p_phase) { parse_attributes(p_att); } unsigned good() const { return parse_error.empty(); } std::string getErrorReason() const { return parse_error; } private: bool parse_attributes(const easystring &tmp_att) { int i, att_num; std::vector sv; att_num = split_respect(sv, tmp_att, ";"); // std::cerr << "+++ Number of attributes found: " << att_num << std::endl; easystring key; easystring val; std::size_t index; // unsigned num_quotes1, num_quotes2; for (i=0; i sv; easystring tmp_att; int i, split_num; // We use split_strict since successive tabs are not allowed split_num = split_strict(sv, str, "\t"); if (split_num != 9) { parse_error = "wrong number of tab deliminated fields"; return false; } for (i=0; i<9; ++i) { sv[i].removeSpacesFront(); sv[i].removeSpacesBack(); if ( sv[i].empty() ) { parse_error = "on the tab deliminated line the field with position" + easystring(char(i+49)) + " is empty"; return false; } } seqname = sv[0]; source = sv[1]; feature = sv[2]; fstart = sv[3].ToUnsigned(); fend = sv[4].ToUnsigned(); score = sv[5]; strand = sv[6][0]; // Result must be checked. phase = sv[7][0]; // Result must be checked. tmp_att = sv[8]; if (fstart > fend) { parse_error = "start > end"; return false; } if (strchr("+-?.0",strand) == NULL) { parse_error = easystring("wrong strand symbol \"") + strand + "\". Must be one of \"+-?.0\""; return false; } if (strchr("012+-.", phase) == NULL) { parse_error = easystring("wrong phase symbol \"") + phase + "\". Must be one of \"012+-.\""; return false; } return parse_attributes(tmp_att); } public: easystring getSeqid () { return seqname; } easystring getSource () { return source; } easystring getFeature () { return feature; } unsigned getStart () { return fstart; } unsigned getEnd () { return fend; } unsigned getStartIndex () { return fstart-1; } // Lowest index is 0 unsigned getEndIndex () { return fend; } // Is index after last index that lies in the feature. // This is equal to the last position in feature. fend has lowest value 1. // Example: Start codon at beginning of sequence: gff positions 1,3. Sequence indices: 0,3 easystring getScoreAsString() { return score; } /* std::pair getScore() */ /* { */ /* if (score.size() == 1 && score[0] == '.') */ /* return make_pair(false, 0); */ /* else */ /* return make_pair(true, score.ToDouble()); */ /* } */ char getStrand () { return strand; } char getPhase () { return phase; } unsigned length() { return fend-fstart; } const vector& getAttributeNames() { return att_names; } const vector& getAttributeNamesLowerCase() { return att_names_lower_case; } int getIndexOfAttribute(const easystring &s, bool lower_case_comparison = false) { int i = 0, n = att_names.size(); if (!lower_case_comparison) while (i < n && att_names[i] != s) { ++i; } else while (i < n && att_names_lower_case[i] != s) { ++i; } if (i==n) return -1; else return i; } unsigned countValuesOfAttribute(const easystring &s, bool lower_case_comparison = false) { int i = getIndexOfAttribute(s, lower_case_comparison); if (i == -1) return 0; else return att_values[i].countChar(',')+1; } unsigned countValuesOfAttribute(unsigned i) { if (i >= att_names.size()) return 0; else return att_values[i].countChar(',')+1; } const easystring &getValueOfAttribute(const easystring &s, bool lower_case_comparison = false) { int i = getIndexOfAttribute(s, lower_case_comparison); if (i == -1) return empty_easy_string; else return att_values[i]; } const easystring &getValueOfAttribute(unsigned i) { if (i >= att_names.size()) return empty_easy_string; else return att_values[i]; } bool isFeature(const easystring &str) { return (str == feature); } void print(ostream &os, int flag=0) { unsigned i; if ( !good() ) { os << "Invalid gff recored." << endl; os << "Reason: " << parse_error << endl; return; } if (flag == 0) // gff output format { os << seqname << "\t" << source << "\t" << feature << "\t" << fstart << "\t" << fend << "\t" << score << "\t" << strand << "\t" << phase << "\t"; for (i=0; i < att_names.size()-1; ++i) { os << att_names[i] << "=" << getValueOfAttribute(att_names[i]) << "; "; } os << att_names[i] << "=" << getValueOfAttribute(att_names[i]); } else if (flag == 1) // long multiline format { os << "seqname: " << seqname << endl << "source: " << source << endl << "feature: " << feature << endl << "start: " << fstart << endl << "end: " << fend << endl << "score: " << score << endl << "strand: " << strand << endl << "phase: " << phase << endl; for (i=0; i < att_names.size(); ++i) { os << "attribute: (" << att_names[i] << ") number of values: " << countValuesOfAttribute(att_names[i]) << ", value: " << getValueOfAttribute(att_names[i]) << endl; } } } /* bool is_in_range(unsigned a, unsigned e) */ /* { */ /* return is_r2_Subrange_of_r1(a, e, fstart, fend); */ /* } */ /* unsigned overlap_with_range(unsigned a, unsigned e) */ /* { */ /* return overlap(a, e, fstart, fend); */ /* } */ /* void union_with_range(unsigned a, unsigned e, unsigned &c1, unsigned &c2) */ /* { */ /* range_union(a, e, fstart, fend, c1, c2); */ /* } */ /* void intersection_with_range(unsigned a, unsigned e, unsigned &c1, unsigned &c2) */ /* { */ /* range_intersection(a, e, fstart, fend, c1, c2); */ /* } */ bool print_sequence(FILE *of, easystring format, CSequence_Mol &seq, int char_per_line, bool ref_comp_if_neg_direction = true ) { // the name of the sequence we print: easystring seq_name; string strand_desc; unsigned i; if (seq.getName() != seqname) return false; // %I seqID // %S source // %F feature // %b begin // %e end // %s score // %d strand (Direction) short // %D strand (Direction) long // %p phase // %A attribute 0 if ( format.empty() ) { format = "%I#%S#%F#%b-%e#%p#%A%D"; } unsigned N = format.size(); for (i=0; i < N; ++i) { if (format[i] == '\\' ) { ++i; if (i == N) break; seq_name += format[i]; } else if (format[i] == '%') { ++i; if (i == N) break; switch(format[i]) { case 'I': seq_name += seqname; break; case 'S': seq_name += source; break; case 'F': seq_name += feature; break; case 'b': seq_name += easystring(fstart); break; case 'e': seq_name += easystring(fend); break; case 's': seq_name += score; break; case 'd': seq_name += strand; break; case 'D': if ( strand == '+') { strand_desc = "on+strand_is+strand"; } else if ( strand == '-' ) { if (ref_comp_if_neg_direction) { seq_name += "on-strand_is-strand"; } else { seq_name += "on-strand_is+strand"; } } else { seq_name += "not-stranded"; } break; case 'p': seq_name += easystring( phase ); break; case 'A': seq_name += getValueOfAttribute(0); break; default: seq_name += easystring(format[i]); break; } } else seq_name += easystring(format[i]); } /* seq_name = */ /* seqname + */ /* string("|") + */ /* source + */ /* string("|") + */ /* feature + */ /* string("|") + */ /* easystring( fstart ) + */ /* string(":") + */ /* easystring( fend ) + */ /* string("|") + */ /* score + */ /* string("|") + */ /* easystring( strand ) + */ /* string("|") + */ /* easystring( phase ) + */ /* string("|") + */ /* getValueOfAttribute(0) + */ /* string("|") + */ /* strand_desc; */ bool revComp = ref_comp_if_neg_direction && strand == '-'; // fend is position at which feature ends. // The following write function expects 0 based indizes, // Example: print first three bases, pass 0 and 3 in both cases, we have 1 and 3 if (revComp) seq.writeSequence_revComp(of, fstart-1, fend, seq_name.c_str(), char_per_line); else seq.writeSequence(of, fstart-1, fend, seq_name.c_str(), char_per_line); return true; } // friend functions: friend unsigned overlap(GFF_record &a, GFF_record &b) { if (a.seqname != b.seqname) return 0; return overlap(a.fstart, a.fend, b.fstart, b.fend); } friend unsigned overlap_in_same_direction(GFF_record &a, GFF_record &b) { if (a.strand != b.strand) return 0; if (a.seqname != b.seqname) return 0; return overlap(a.fstart, a.fend, b.fstart, b.fend); } friend bool position_lessThan_GFF_record(GFF_record &a, GFF_record &b) { if (a.seqname != b.seqname) return a.seqname < b.seqname; if (a.fstart < b.fstart) return true; if (a.fstart > b.fstart) return false; // We have a.fstart == b.fstart now!!! if ( equalRange(a, b) ) { if ( a.feature == "exon" ) return true; else return false; } if ( b.fend < a.fend ) return true; else return false; } friend bool position_lessThan_GFF_record_pointer(GFF_record *a, GFF_record *b) { if (a->seqname != b->seqname) return a->seqname < b->seqname; if (a->fstart < b->fstart) return true; if (a->fstart > b->fstart) return false; // We have a.fstart == b.fstart now!!! if ( equalRange(*a, *b) ) { if ( a->feature == "exon" ) return true; else return false; } if ( b->fend < a->fend ) return true; else return false; } friend bool operator==(GFF_record &a, GFF_record &b) { if (a.fstart != b.fstart || a.fend != b.fend) return false; if (a.feature != b.feature) return false; if (a.seqname != b.seqname) return false; if (a.source != b.source) return false; if (a.score != b.score) return false; if (a.strand != b.strand) return false; if (a.phase != b.phase) return false; if (a.att_names != b.att_names) return false; if (a.att_values != b.att_values) return false; return true; } friend bool equalRange(GFF_record &a, GFF_record &b) { return equalRange(a.fstart, a.fend, b.fstart, b.fend); } friend bool isSubfeature_Arg2_of_Arg1(GFF_record &a, GFF_record &b) { return is_r2_Subrange_of_r1(a.fstart, a.fend, b.fstart, b.fend); } }; #endif