ngs_server 0.1 → 0.2

data/ext/vcftools/cpp/.svn/text-base/vcf_entry_setters.cpp.svn-base

@@ -0,0 +1,482 @@
+/*
+ * vcf_entry_setters.cpp
+ *
+ *  Created on: Nov 11, 2009
+ *      Author: Adam Auton
+ *      ($Revision: 230 $)
+ */
+
+#include "vcf_entry.h"
+
+void vcf_entry::set_CHROM(const string &in)
+{
+	CHROM = in;
+}
+
+void vcf_entry::set_POS(const int in)
+{
+	POS = in;
+}
+
+void vcf_entry::set_ID(const string &in)
+{
+	ID = in;
+}
+
+void vcf_entry::set_REF(const string &in)
+{
+	REF = in;
+}
+
+void vcf_entry::set_ALT(const string &in)
+{
+	istringstream ss(in);
+	string tmpstr;
+	ALT.resize(0);
+	while(!ss.eof())
+	{
+		getline(ss, tmpstr, ',');
+		add_ALT_allele(tmpstr);
+	}
+	parsed_ALT = true;
+}
+
+void vcf_entry::add_ALT_allele(const string &in)
+{
+	if (in != ".")
+	{
+		if (find(ALT.begin(), ALT.end(),in) == ALT.end())
+		{
+			ALT.push_back(in);
+		}
+	}
+	parsed_ALT = true;
+}
+
+void vcf_entry::set_QUAL(const double in)
+{
+	QUAL = in;
+}
+
+void vcf_entry::add_FILTER_entry(const string &in)
+{
+	if ((in != "PASS") && (in != "."))
+		if (find(FILTER.begin(), FILTER.end(), in) == FILTER.end())
+			FILTER.push_back(in);
+	sort(FILTER.begin(), FILTER.end());
+	parsed_FILTER = true;
+}
+
+void vcf_entry::set_FORMAT(const string &in)
+{
+	FORMAT.resize(0);
+	FORMAT_to_idx.clear();
+
+	if (in.size() > 0)
+	{
+		istringstream ss(in);
+		string tmpstr;
+
+		unsigned int pos=0;
+		while(!ss.eof())
+		{
+			getline(ss, tmpstr, ':');
+			add_FORMAT_entry(tmpstr, pos);
+			pos++;
+		}
+	}
+
+	GT_idx = -1;
+	GQ_idx = -1;
+	DP_idx = -1;
+	FT_idx = -1;
+
+	if (FORMAT_to_idx.find("GT") != FORMAT_to_idx.end())
+		GT_idx = FORMAT_to_idx["GT"];
+	if (FORMAT_to_idx.find("GQ") != FORMAT_to_idx.end())
+		GQ_idx = FORMAT_to_idx["GQ"];
+	if (FORMAT_to_idx.find("DP") != FORMAT_to_idx.end())
+		DP_idx = FORMAT_to_idx["DP"];
+	if (FORMAT_to_idx.find("FT") != FORMAT_to_idx.end())
+		FT_idx = FORMAT_to_idx["FT"];
+
+	parsed_FORMAT = true;
+}
+
+void vcf_entry::add_FORMAT_entry(const string &in, unsigned int pos)
+{
+	FORMAT.push_back(in);
+	FORMAT_to_idx[in] = pos;
+}
+
+// The following function reads in a genotype from a '0/1'-like string.
+// Should handle haploid types to, but NOT polyploidy.
+void vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const string &in)
+{
+	ploidy.resize(N_indv);
+	if ((in.size() == 3) && ((in.c_str()[1] == '/') || (in.c_str()[1] == '|')))
+	{	// Fast, diploid case...
+		ploidy[indv] = 2;
+		set_indv_PHASE(indv, in.c_str()[1]);
+		set_indv_GENOTYPE_alleles(indv, in.c_str()[0], in.c_str()[2]);
+	}
+	else
+	{	// More complex case...
+		size_t pos = in.find_first_of("/|");
+		if (pos != string::npos)
+		{	// autosome
+			ploidy[indv] = 2;
+			set_indv_PHASE(indv, in[pos]);
+			set_indv_GENOTYPE_alleles(indv, make_pair(in.substr(0,pos), in.substr(pos+1)));
+		}
+		else
+		{	// Male chrX, or chrY
+			ploidy[indv] = 1;
+			set_indv_PHASE(indv, '|');
+			set_indv_GENOTYPE_alleles(indv, make_pair(in.substr(0,pos), "."));
+		}
+
+		// Check for polypoidy
+		size_t pos2 = in.find_last_of("/|");
+		if (pos != pos2)
+			error("Polypolidy found, and not supported: " + CHROM + ":" + int2str(POS));
+	}
+
+	parsed_GT[indv] = true;
+}
+
+void vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<int, int> &genotype, char phase)
+{
+	set_indv_GENOTYPE_ids(indv, genotype);
+	set_indv_PHASE(indv, phase);
+	parsed_GT[indv] = true;
+}
+
+void vcf_entry::set_indv_GENOTYPE_and_PHASE(unsigned int indv, const pair<string, string> &genotype, char phase)
+{
+	set_indv_GENOTYPE_alleles(indv, genotype);
+	set_indv_PHASE(indv, phase);
+	parsed_GT[indv] = true;
+}
+
+void vcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, const pair<string, string> &in)
+{
+	if (GENOTYPE.size() == 0)
+		GENOTYPE.resize(N_indv, make_pair(-1,-1));
+
+	pair<int, int> a(-1,-1);
+
+	if (in.first != ".")
+		a.first = str2int(in.first);
+
+	if (in.second != ".")
+		a.second = str2int(in.second);
+
+	GENOTYPE[indv] = a;
+	parsed_GT[indv] = true;
+}
+
+void vcf_entry::set_indv_GENOTYPE_alleles(unsigned int indv, char a1, char a2)
+{
+	if (GENOTYPE.size() == 0)
+		GENOTYPE.resize(N_indv, make_pair(-1,-1));
+
+	pair<int, int> a(-1,-1);
+
+	if (a1 != '.')
+		a.first = a1 - '0';
+
+	if (a2 != '.')
+		a.second = a2 - '0';
+
+	GENOTYPE[indv] = a;
+	parsed_GT[indv] = true;
+}
+
+
+void vcf_entry::set_indv_GENOTYPE_ids(unsigned int indv, const pair<int, int> &in)
+{
+	if (GENOTYPE.size() == 0)
+		GENOTYPE.resize(N_indv, make_pair(-1,-1));
+	GENOTYPE[indv] = in;
+}
+
+void vcf_entry::set_indv_PHASE(unsigned int indv, char in)
+{
+	if (PHASE.size() == 0)
+		PHASE.resize(N_indv, '/');
+
+	PHASE[indv] = in;
+	parsed_GT[indv] = true;
+}
+
+void vcf_entry::set_indv_GQUALITY(unsigned int indv, double in)
+{
+	parsed_GQ[indv] = true;
+	if (in == -1)
+		return;
+	if (GQUALITY.size() == 0)
+		GQUALITY.resize(N_indv, -1);
+
+	if (in > 99)
+		in = 99;
+	GQUALITY[indv] = in;
+}
+
+void vcf_entry::set_indv_DEPTH(unsigned int indv, int in)
+{
+	parsed_DP[indv] = true;
+	if (in == -1)
+		return;
+	if (DEPTH.size() == 0)
+		DEPTH.resize(N_indv, -1);
+
+	DEPTH[indv] = in;
+}
+
+void vcf_entry::add_indv_GFILTER(unsigned int indv, const string &in)
+{
+	if (GFILTER.size() == 0)
+		GFILTER.resize(N_indv);
+
+	if (in != ".")
+		if (find(GFILTER[indv].begin(), GFILTER[indv].end(), in) == GFILTER[indv].end())
+			GFILTER[indv].push_back(in);
+	parsed_FT[indv] = true;
+}
+
+void vcf_entry::set_indv_GFILTER(unsigned int indv, const string &in)
+{
+	parsed_FT[indv] = true;
+	if ((in.size() == 0) || (in == "."))
+		return;
+
+	if (GFILTER.size() == 0)
+		GFILTER.resize(N_indv);
+
+	GFILTER[indv].resize(0);
+
+	static istringstream ss;
+	static string ith_FILTER;
+	ss.clear();
+	ss.str(in);
+	while (!ss.eof())
+	{
+		getline(ss, ith_FILTER, ';');
+
+		if ((ith_FILTER.size()==0) || (ith_FILTER == "."))
+			continue;	// Don't bother storing "unfiltered" state.
+
+		GFILTER[indv].push_back(ith_FILTER);
+	}
+}
+
+void vcf_entry::set_FILTER(const string &FILTER_str)
+{
+	FILTER.resize(0);
+	passed_filters = false;
+	if (FILTER_str == "PASS")
+		passed_filters = true;
+	else
+	{
+		if (FILTER_str != ".")
+		{
+			istringstream ss(FILTER_str);
+			string ith_FILTER;
+			while (!ss.eof())
+			{
+				getline(ss, ith_FILTER, ';');
+				FILTER.push_back(ith_FILTER);
+			}
+		}
+	}
+	sort(FILTER.begin(), FILTER.end());
+	parsed_FILTER = true;
+}
+
+void vcf_entry::set_INFO(const string &INFO_str)
+{
+	INFO.resize(0);
+	if ((INFO_str.size() > 0) && (INFO_str != "."))
+	{
+		istringstream ss(INFO_str);
+		string tmpstr;
+		while(!ss.eof())
+		{
+			getline(ss, tmpstr, ';');
+
+			istringstream ss2(tmpstr);
+			getline(ss2, tmpstr, '=');
+			pair<string, string> INFO_entry(tmpstr, ".");
+
+			if (!ss2.eof())
+			{	// If there is a value entry, read it now
+				getline(ss2, tmpstr);
+				INFO_entry.second = tmpstr;
+			}
+			else	// Otherwise, set it equal to 1
+				INFO_entry.second = "1";
+
+			INFO.push_back(INFO_entry);
+		}
+	}
+	parsed_INFO = true;
+}
+
+void vcf_entry::add_INFO_descriptor(const string &in)
+{
+	size_t found=in.find("##INFO=");
+	if (found!=string::npos)
+	{	// Found an INFO descriptor
+		size_t found_start=in.find_first_of("<");
+		size_t found_end=in.find_last_of(">");
+		string details = in.substr(found_start+1, found_end-found_start-1);
+		Field_description I;
+
+		vector<string> tokens;
+		tokenize(details, ',', tokens);
+		if (tokens.size() < 4)
+			error("Expected 4 parts in INFO definition: " + in);
+
+		vector<string> entry;
+		tokenize(tokens[0], '=', entry);
+		if (entry[0] == "ID") I.ID = entry[1];
+		else error("Expected ID entry as first field in INFO description: " + in);
+
+		tokenize(tokens[1], '=', entry);
+		if (entry[0] == "Number")
+		{	// TODO - handle 'A' and 'G' categories correctly.
+			if ((entry[1] == "A") || (entry[1] == "G"))
+				I.N_entries = -1;	// Currently just treat as missing.
+			else
+				I.N_entries =  str2int(entry[1]);
+		}
+		else error("Expected Number entry as second field in INFO description: " + in);
+
+		tokenize(tokens[2], '=', entry);
+		if (entry[0] == "Type")
+		{
+			if (entry[1] == "Integer") I.Type = Integer;
+			else if ((entry[1] == "Float") || (entry[1] == "Numeric")) I.Type = Float;
+			else if (entry[1] == "Character") I.Type = Character;
+			else if (entry[1] == "String") I.Type = String;
+			else if (entry[1] == "Flag")
+			{
+				I.Type = Flag;
+				if (I.N_entries != 0) error("Flag Type must have 0 entries: " + in);
+			}
+			else error("Unknown Type in INFO meta-information: " + in);
+		}
+		else error("Expected Type entry as third field in INFO description: " + in);
+
+		tokenize(tokens[3], '=', entry);
+		if (entry[0] == "Description")
+		{
+			I.Description = entry[1];
+			for (unsigned int i=4; i<tokens.size(); i++)
+			{
+				I.Description += "; " + tokens[i];
+			}
+		}
+		else error("Expected Description entry as fourth field in INFO description: " + in);
+
+		INFO_map[I.ID] = I;
+	}
+}
+
+void vcf_entry::add_FILTER_descriptor(const string &in)
+{
+	size_t found=in.find("##FILTER=");
+	if (found!=string::npos)
+	{
+		size_t found_start=in.find_first_of("<");
+		size_t found_end=in.find_last_of(">");
+		string details = in.substr(found_start+1, found_end-found_start-1);
+		vector<string> tokens;
+		tokenize(details, ',', tokens);
+
+		if (tokens.size() < 2)
+			error("Expected 2 parts in FILTER definition: " + in);
+
+		string ID, Description;
+		vector<string> entry;
+		tokenize(tokens[0], '=', entry);
+		if (entry[0] == "ID") ID = entry[1];
+		else error("Expected ID as first field in FILTER description: " + in);
+
+		tokenize(tokens[1], '=', entry);
+		if (entry[0] == "Description")
+		{
+			Description = entry[1];
+			for (unsigned int i=2; i<tokens.size(); i++)
+			{
+				Description += "; " + tokens[i];
+			}
+		}
+		else
+			error("Expected Description as second field in FILTER description: " + in);
+
+		FILTER_map[ID] = Description;
+	}
+}
+
+void vcf_entry::add_FORMAT_descriptor(const string &in)
+{
+	size_t found=in.find("##FORMAT=");
+	if (found!=string::npos)
+	{	// Found an FORMAT descriptor
+		size_t found_start=in.find_first_of("<");
+		size_t found_end=in.find_last_of(">");
+		string details = in.substr(found_start+1, found_end-found_start-1);
+		vector<string> tokens;
+		tokenize(details, ',', tokens);
+		Field_description I;
+
+		if (tokens.size() < 4)
+			error("Expected 4 parts in FORMAT definition: " + in);
+
+		vector<string> entry;
+		tokenize(tokens[0], '=', entry);
+		if (entry[0] == "ID") I.ID = entry[1];
+		else error("Expected ID entry as first field in FORMAT description: " + in);
+
+		tokenize(tokens[1], '=', entry);
+		if (entry[0] == "Number")
+		{	// TODO - handle 'A' and 'G' categories correctly.
+			if ((entry[1] == "A") || (entry[1] == "G"))
+				I.N_entries = -1;	// Currently just treat as missing.
+			else
+				I.N_entries = str2int(entry[1]);
+		}
+		else error("Expected Number entry as second field in FORMAT description: " + in);
+
+		tokenize(tokens[2], '=', entry);
+		if (entry[0] == "Type")
+		{
+			if (entry[1] == "Integer") I.Type = Integer;
+			else if ((entry[1] == "Float") || (entry[1] == "Numeric")) I.Type = Float;
+			else if (entry[1] == "Character") I.Type = Character;
+			else if (entry[1] == "String") I.Type = String;
+			else if (entry[1] == "Flag")
+			{
+				I.Type = Flag;
+				if (I.N_entries != 0) error("Flag Type must have 0 entries: " + in);
+			}
+			else error("Unknown Type in FORMAT meta-information: " + in);
+		}
+		else error("Expected Type entry as third field in FORMAT description: " + in);
+
+		tokenize(tokens[3], '=', entry);
+		if (entry[0] == "Description")
+		{
+			I.Description = entry[1];
+			for (unsigned int i=4; i<tokens.size(); i++)
+			{
+				I.Description += "; " + tokens[i];
+			}
+		}
+		else error("Expected Description entry as fourth field in FORMAT description: " + in);
+
+		FORMAT_map[I.ID] = I;
+	}
+}