/* 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 CTAXONNAMESDICTIONARY_H #define CTAXONNAMESDICTIONARY_H #include "faststring2.h" #include "CDistance_matrix.h" #include "CSequences2.h" #include "CFile/CFile2_1.h" #include "CSeqNameList.h" #include #include #include #include class CTaxonNamesDictionary { CSeqNameList *snl; CSeqNameList all; // Each index stored in the taxon_names_to_index map is equal to the index of the same taxon name in the taxon_names_vec. // This allows us to translate indices and names back and forth. std::vector taxon_names_vec; std::map taxon_names_to_index; public: CTaxonNamesDictionary(faststring directoryname, std::list &list_of_fasta_file_names, unsigned short sequence_name_taxon_field_number, char field_delimiter):all(true) { // Collect all taxon names to build a taxon name dictionary // The collection of all sequence names is stored in the all object. faststring full_transcript_file_name; std::list::iterator file_names_it, file_names_it_end, file_names_it_begin; file_names_it_begin = file_names_it = list_of_fasta_file_names.begin(); file_names_it_end = list_of_fasta_file_names.end(); // For each fasta file while (file_names_it != file_names_it_end) { full_transcript_file_name = directoryname + "/" + *file_names_it; // std::cout << "Reading sequence names in " << full_transcript_file_name << std::endl; snl = new CSeqNameList(full_transcript_file_name.c_str(), true); if (file_names_it == file_names_it_begin) { all.set_to(*snl, "all-names-union"); } else { all.add_List_non_redundant(*snl); } ++file_names_it; } // all.print(cout,0); // TAXON NAMES DICTIONARY: consists of a vector, and map // A set is used to store all names temporarily. std::set taxon_names_set; bool error_get_set_of_name_field; // Take the names of the sequences, divide it according to the delimiter '|' and // extract field number sequence_name_taxon_field_number. Store all names in the set. error_get_set_of_name_field = all.get_set_of_name_field(sequence_name_taxon_field_number+1, field_delimiter, taxon_names_set); if (error_get_set_of_name_field) { std::cerr << "WARNING: At least one error occurred when trying to read taxon names from the fasta sequence headers." << " Usually this error occurs, when headers are not in the proper format, when the parameter file contains a wrong" << " wrong sequence name field delimiter or if the taxon name field number is wrong." << std::endl; std::cerr << "This error will influence: TODO." << std::endl; } // Now we have a set that contains all taxon names found in all fasta files. std::set::iterator it, it_end; it = taxon_names_set.begin(); it_end = taxon_names_set.end(); unsigned i; i=0; while (it != it_end) { // Since the taxon_names_vec was empty originally, the names have an index equal to i. taxon_names_vec.push_back(*it); // push all names into the vector. unique-index -> name taxon_names_to_index[*it] = i; // for each name store its index in the map. name -> unique-index ++it; ++i; } // Now we can translate unique indices and taxon names back and forth. } void print(std::ostream &outfile) { outfile << "## Index <-> taxon name:" << std::endl; unsigned i, N = taxon_names_vec.size(); for (i=0; i::iterator it, it_end; */ /* it = taxon_names_to_index.begin(); */ /* it_end = taxon_names_to_index.end(); */ /* cout << "taxon_names_to_index map" << endl; */ /* while (it != it_end) */ /* { */ /* cout << it->first << "=>" << it->second << endl; */ /* ++it; */ /* } */ std::map::iterator it_find = taxon_names_to_index.find(taxonname); if (it_find != taxon_names_to_index.end() ) return it_find->second; else return -1u; } const std::vector & get_taxon_names_vec() { return taxon_names_vec; } void print_taxon_names_to_index(std::ostream &os) { std::map::iterator it, it_end; it = taxon_names_to_index.begin(); it_end = taxon_names_to_index.end(); os << "Content of taxon names to global index dictionary: " << std::endl; while (it != it_end) { os.width(30); os << it->first << " " << it->second << std::endl; ++it; } } }; #endif