/**
* Evaluates the actions for this node.
*/
void Node::evaluate(bcf_hdr_t *h, bcf1_t *v, Variant *variant, bool debug)
{
if (debug)
std::cerr << "evaluation " << type << "\n";
if (type&VT_LOGIC_OP)
{
if (type==VT_NOT)
{
if (debug)
std::cerr << "\tVT_NOT " << left->value << " \n";
value = !(left->value);
}
else if (type==VT_AND)
{
if (debug)
std::cerr << "\tVT_AND " << left->value << "&" << right->value << " \n";
value = (left->value && right->value);
}
else if (type==VT_OR)
{
value = (left->value || right->value);
}
}
else if (type&VT_MATH_CMP)
{
if (type==VT_EQ)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
if (debug)
std::cerr << "\tVT_EQ " << left->i << "&" << right->i << " \n";
value = (left->i==right->i);
return;
}
else if ((right->type&VT_FLT))
{
if (debug)
std::cerr << "\tVT_EQ " << left->i << "&" << right->f << " \n";
value = (left->i==right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
if (debug)
std::cerr << "\tVT_EQ " << left->f << "&" << right->i << " \n";
value = (left->f==right->i);
return;
}
else if ((right->type&VT_FLT))
{
if (debug)
std::cerr << "\tVT_EQ " << left->f << "&" << right->f << " \n";
value = (left->f==right->f);
return;
}
}
else if ((left->type&VT_STR) && (right->type&VT_STR))
{
if (debug)
std::cerr << "\tVT_EQ " << left->tag.s << "&" << right->tag.s << " \n";
value = strcmp(left->tag.s, right->tag.s)==0 ? true : false;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported : == %d %d\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else if (type==VT_NE)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
value = (left->i!=right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->i!=right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
value = (left->f!=right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->f!=right->f);
return;
}
}
else if ((left->type&VT_STR) && (right->type&VT_STR))
{
value = strcmp(left->tag.s, right->tag.s)==0 ? false : true;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported: %d %d: !=\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else if (type==VT_LE)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
value = (left->i<=right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->i<=right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
type |= VT_INT;
value = (left->f<=right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->f<=right->f);
return;
}
}
else if ((left->type&VT_STR) && (right->type&VT_STR))
{
value = strcmp(left->tag.s, right->tag.s)<=0 ? true : false;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported: %d %d: <=\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else if (type==VT_GE)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
value = (left->i>=right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->i>=right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
value = (left->f>=right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->f>=right->f);
return;
}
}
else if ((left->type&VT_STR) && (right->type&VT_STR))
{
value = strcmp(left->tag.s, right->tag.s)>=0 ? true : false;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported: %d %d: >=\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else if (type==VT_GT)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
value = (left->i>right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->i>right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
value = (left->f>right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->f>right->f);
return;
}
}
else if ((left->type&VT_STR) && (right->type&VT_STR))
{
value = strcmp(left->tag.s, right->tag.s)>0 ? true : false;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported: %d %d: >\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else if (type==VT_LT)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
value = (left->i<right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->i<right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
value = (left->f<right->i);
return;
}
else if ((right->type&VT_FLT))
{
value = (left->f<right->f);
return;
}
}
else if ((left->type&VT_STR) && (right->type&VT_STR))
{
value = strcmp(left->tag.s, right->tag.s)<0 ? true : false;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported: %d %d: <\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
}
else if (type&VT_BCF_OP)
{
if (type==VT_FILTER)
{
if (bcf_has_filter(h, v, tag.s)!=1)
{
value = false;
}
else
{
value = true;
}
}
else if (type==VT_INFO)
{
int32_t *data = NULL;
int32_t n=0;
if (bcf_get_info_int32(h, v, tag.s, &data, &n)>0)
{
type |= VT_INT;
i = *data;
f = (float)i;
}
else if (bcf_get_info_float(h, v, tag.s, &data, &n)>0)
{
type |= VT_FLT;
f = (float)(*data);
}
else if (bcf_get_info_string(h, v, tag.s, &data, &n)>0)
{
type |= VT_STR;
s.l=0;
for (int32_t i=0; i<n; ++i)
{
kputc(data[i], &s);
}
}
else if (bcf_get_info_flag(h, v, tag.s, 0, 0)>0)
{
type |= VT_FLG;
i = 1;
f = 1;
b = true;
value = true;
s.l=0;
}
else
{
i = 0;
f = 0;
b = false;
value = false;
s.l=0;
}
if (n) free(data);
}
else if (type==(VT_INFO|VT_INT))
{
int32_t *data = NULL;
int32_t n=0;
if (bcf_get_info_int32(h, v, tag.s, &data, &n)>0)
{
i = *((int*)data);
}
if (n) free(data);
}
else if (type==(VT_INFO|VT_FLT))
{
int32_t *data = NULL;
int32_t n=0;
if (bcf_get_info_float(h, v, tag.s, &data, &n)>0)
{
f = *((float*)data);
}
if (n) free(data);
}
else if (type==(VT_INFO|VT_STR))
{
int32_t *data = NULL;
int32_t n=0;
if (bcf_get_info_string(h, v, tag.s, &data, &n)>0)
{
s.l=0;
for (int32_t i=0; i<n; ++i)
{
kputc(data[i], &s);
}
}
if (n) free(data);
}
else if (type==(VT_INFO|VT_FLG))
{
if (bcf_get_info_flag(h, v, tag.s, 0, 0)>0)
{
i = 1;
f = 1;
b = true;
value = true;
//s.l=0; kputc('1', &s);
}
else
{
i = 0;
f = 0;
b = false;
value = false;
s.l=0;
}
if (debug)
std::cerr << "\tVT_INFO|VT_FLG " << i << " " << f << " " << b << " " << value << " " << s.s << " \n";
}
else if (type==VT_VARIANT_TYPE)
{
if (debug)
std::cerr << "\tVTYPE " << variant->vtype2string(variant->type) << " \n";
i = variant->type;
value = i;
}
else if (type==VT_VARIANT_DLEN)
{
if (debug)
std::cerr << "\tDLEN " << variant->alleles[0].dlen << " \n";
i = variant->alleles[0].dlen;
value = i;
}
else if (type==VT_VARIANT_LEN)
{
if (debug)
std::cerr << "\tLEN " << abs(variant->alleles[0].dlen) << " \n";
i = abs(variant->alleles[0].dlen);
value = i;
}
else if (type==VT_N_ALLELE)
{
if (debug)
std::cerr << "\tN_ALLELE " << bcf_get_n_allele(v) << " \n";
i = bcf_get_n_allele(v);
}
}
else if (type&VT_MATH_OP)
{
if ((type&8207)==VT_ADD)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
type |= VT_INT;
i = (left->i+right->i);
return;
}
else if ((right->type&VT_FLT))
{
type |= VT_FLT;
f = (left->i+right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
type |= VT_FLT;
f = (left->f+right->i);
return;
}
else if ((right->type&VT_FLT))
{
type |= VT_FLT;
f = (left->f+right->f);
return;
}
}
fprintf(stderr, "[%s:%d %s] evaluation not supported : +\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
else if ((type&8207)==VT_SUB)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
type |= VT_INT;
i = (left->i-right->i);
return;
}
else if ((right->type&VT_FLT))
{
type |= VT_FLT;
f = (left->i-right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
type |= VT_FLT;
f = (left->f-right->i);
return;
}
else if ((right->type&VT_FLT))
{
type |= VT_FLT;
f = (left->f-right->f);
return;
}
}
fprintf(stderr, "[%s:%d %s] evaluation not supported : -\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
else if ((type&8207)==VT_MUL)
{
if ((left->type&VT_INT))
{
if ((right->type&VT_INT))
{
type |= VT_INT;
i = (left->i*right->i);
return;
}
else if ((right->type&VT_FLT))
{
type |= VT_FLT;
f = (left->i*right->f);
return;
}
}
else if ((left->type&VT_FLT))
{
if ((right->type&VT_INT))
{
type |= VT_FLT;
f = (left->f*right->i);
return;
}
else if ((right->type&VT_FLT))
{
type |= VT_FLT;
f = (left->f*right->f);
return;
}
}
fprintf(stderr, "[%s:%d %s] evaluation not supported : *\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
else if ((type&8207)==VT_DIV)
{
if (left->type&VT_INT)
{
if (right->type&VT_INT)
{
type |= VT_FLT;
f = ((float)left->i/right->i);
return;
}
else if (right->type&VT_FLT)
{
type |= VT_FLT;
f = (left->i/right->f);
return;
}
}
else if (left->type&VT_FLT)
{
if (right->type&VT_INT)
{
type |= VT_FLT;
f = (left->f/right->i);
return;
}
else if (right->type&VT_FLT)
{
type |= VT_FLT;
f = (left->f/right->f);
return;
}
}
fprintf(stderr, "[%s:%d %s] evaluation not supported : /\n", __FILE__, __LINE__, __FUNCTION__);
exit(1);
}
else if (type==VT_BIT_AND)
{
if ((left->type&VT_INT) && (right->type&VT_INT))
{
i = (left->i & right->i);
value = i;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported for & : %d %d\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else if (type==VT_BIT_OR)
{
if ((left->type&VT_INT) && (right->type&VT_INT))
{
i = (left->i | right->i);
value = i;
return;
}
fprintf(stderr, "[%s:%d %s] evaluation not supported for | : %d %d\n", __FILE__, __LINE__, __FUNCTION__, left->type, right->type);
exit(1);
}
else
{
fprintf(stderr, "[%s:%d %s] math op not supported : %d\n", __FILE__, __LINE__, __FUNCTION__, (type&15));
exit(1);
}
}
}
/**
* Constructor.
* @v - VCF record.
*/
GenotypingRecord::GenotypingRecord(bcf_hdr_t *h, bcf1_t *v, int32_t vtype)
{
clear();
this->h = h;
this->v = v;
rid = bcf_get_rid(v);
pos1 = bcf_get_pos1(v);
this->vtype = vtype;
int32_t n_allele = bcf_get_n_allele(v);
if (vtype==VT_SNP && n_allele==2)
{
rid = bcf_get_rid(v);
beg1 = bcf_get_pos1(v);
end1 = beg1;
}
else if (vtype==VT_INDEL && bcf_get_n_allele(v)==2)
{
rid = bcf_get_rid(v);
char** alleles = bcf_get_allele(v);
dlen = strlen(alleles[1])-strlen(alleles[0]);
len = abs(dlen);
int32_t *flanks = NULL;
int32_t n = 0;
if (bcf_get_info_int32(h, v, "FLANKS", &flanks, &n)>0)
{
lend1 = flanks[0];
rbeg1 = flanks[1];
free(flanks);
}
else
{
lend1 = bcf_get_pos1(v) - 1;
rbeg1 = bcf_get_end_pos1(v) + 1;
}
int32_t *fuzzy_flanks = NULL;
n = 0;
if (bcf_get_info_int32(h, v, "FZ_FLANKS", &fuzzy_flanks, &n)>0)
{
fuzzy_lend1 = fuzzy_flanks[0];
fuzzy_rbeg1 = fuzzy_flanks[1];
free(fuzzy_flanks);
}
else
{
fuzzy_lend1 = bcf_get_pos1(v) - 1;
fuzzy_rbeg1 = bcf_get_end_pos1(v) + 1;
}
beg1 = std::min(lend1-2, fuzzy_lend1-2);
end1 = std::max(rbeg1+2, fuzzy_rbeg1+2);
//construct alleles
//get reference sequence
// char* ref_seq = NULL;
// int32_t ref_len = 0;
//// ref_seq = faidx_fetch_seq(fai, bcf_get_chrom(h,v), lend1+1-1, rbeg1-1-1, &ref_len);
//
// for (uint32_t i=0; i<n_allele; ++i)
// {
//
// }
// for ()
// {
// }
//
if (dlen>0)
{
indel.append(&alleles[1][1]);
}
else
{
indel.append(&alleles[0][1]);
}
}
else if (vtype==VT_VNTR)
{
rid = bcf_get_rid(v);
beg1 = bcf_get_pos1(v) - 1;
end1 = bcf_get_end_pos1(v) + 1;
char *motif = NULL;
int32_t n = 0;
if (bcf_get_info_string(h, v, "MOTIF", &motif, &n)>0)
{
this->motif.assign(motif);
free(motif);
}
}
}
