func makeVariant(chrom string, pos int, ref string, alt []string, name string, info string, h *vcfgo.Header) *parsers.Variant {
binfo := vcfgo.NewInfoByte([]byte(info), h)
v := vcfgo.Variant{Chromosome: chrom, Pos: uint64(pos), Reference: ref, Alternate: alt,
Id_: name, Info_: binfo}
return parsers.NewVariant(&v, 0, make([]interfaces.Relatable, 0))
}
// vFromB makes a variant from an interval. this helps avoid code duplication.
func vFromB(b *parsers.Interval) *parsers.Variant {
h := vcfgo.NewHeader()
h.Infos["SVLEN"] = &vcfgo.Info{Id: "SVLEN", Type: "Integer", Description: "", Number: "1"}
m := vcfgo.NewInfoByte([]byte(fmt.Sprintf("SVLEN=%d", int(b.End()-b.Start())-1)), h)
v := parsers.NewVariant(&vcfgo.Variant{Chromosome: b.Chrom(), Pos: uint64(b.Start() + 1),
Reference: "A", Alternate: []string{"<DEL>"}, Info_: m}, 0, b.Related())
return v
}
// AnnotateEnds makes a new 1-base interval for the left and one for the right end
// so that it can use the same machinery to annotate the ends and the entire interval.
// Output into the info field is prefixed with "left_" or "right_".
func (a *Annotator) AnnotateEnds(v interfaces.Relatable, ends string) error {
var err error
// if Both, call the interval, left, and right version to annotate.
if ends == BOTH {
if e := a.AnnotateOne(v, a.Strict); e != nil {
err = e
}
if e := a.PostAnnotate(v.Chrom(), int(v.Start()), int(v.End()), v.(interfaces.IVariant).Info(), ""); e != nil {
err = e
}
if e := a.AnnotateEnds(v, LEFT); e != nil {
err = e
}
if e := a.AnnotateEnds(v, RIGHT); e != nil {
err = e
}
}
if ends == INTERVAL {
err := a.AnnotateOne(v, a.Strict)
err2 := a.PostAnnotate(v.Chrom(), int(v.Start()), int(v.End()), v.(interfaces.IVariant).Info(), "")
if err != nil {
return err
}
return err2
}
// hack:
// modify the variant in-place to create a 1-base variant at the end of
// the interval. annotate that end and then change the position back to what it was.
if ends == LEFT || ends == RIGHT {
// the end is determined by the SVLEN, so we have to make sure it has length 1.
variant := v.(*parsers.Variant).IVariant
var l, r uint32
var ok bool
if ends == LEFT {
l, r, ok = variant.CIPos()
} else {
l, r, ok = variant.CIEnd()
}
// dont reannotate same interval
if !ok && (l == v.Start() && r == v.End()) {
return nil
}
m := vcfgo.NewInfoByte([]byte(fmt.Sprintf("SVLEN=%d;END=%d", r-l-1, r)), variant.(*vcfgo.Variant).Header)
v2 := parsers.NewVariant(&vcfgo.Variant{Chromosome: v.Chrom(), Pos: uint64(l + 1),
Reference: "A", Alternate: []string{"<DEL>"}, Info_: m}, v.Source(), v.Related())
err = a.AnnotateOne(v2, false, ends)
var val interface{}
for _, key := range v2.Info().Keys() {
if key == "SVLEN" || key == "END" {
continue
}
val, err = v2.Info().Get(key)
variant.Info().Set(key, val)
}
err2 := a.PostAnnotate(v.Chrom(), int(l), int(r), variant.Info(), ends)
if err2 != nil {
err = err2
}
}
return err
}
// AnnotatedEnds makes a new 1-base interval for the left and one for the right end
// so that it can use the same machinery to annotate the ends and the entire interval.
// Output into the info field is prefixed with "left_" or "right_".
func (a *Annotator) AnnotateEnds(r interfaces.Relatable, ends string) error {
v, ok := r.(interfaces.VarWrap)
if !ok {
return fmt.Errorf("unable to convert %v to Variant", r)
}
var err error
// if Both, call the interval, left, and right version to annotate.
if ends == BOTH {
// dont want strict for BED.
if e := a.AnnotateOne(v, a.Strict && ok); e != nil {
log.Println(e)
return e
}
if e := a.AnnotateEnds(v, LEFT); e != nil {
log.Println(e)
return e
}
if e := a.AnnotateEnds(v, RIGHT); e != nil {
log.Println(e)
return e
}
// it was a Bed, we add the info to its fields
if !ok {
b := r.(*parsers.Interval)
v.Info().Delete("SVLEN")
b.Fields = append(b.Fields, v.Info().Bytes())
}
return nil
}
if ends == INTERVAL {
return a.AnnotateOne(r, a.Strict)
}
// hack:
// modify the variant in-place to create a 1-base variant at the end of
// the interval. annotate that end and then change the position back to what it was.
if ends == LEFT || ends == RIGHT {
// the end is determined by the SVLEN, so we have to make sure it has length 1.
var l, r uint32
var ok bool
if ends == LEFT {
l, r, ok = v.IVariant.(interfaces.CIFace).CIPos()
} else {
l, r, ok = v.IVariant.(interfaces.CIFace).CIEnd()
}
// dont reannotate same interval
if !ok && (l == v.Start() && r == v.End()) {
return nil
}
m := vcfgo.NewInfoByte([]byte(fmt.Sprintf("SVLEN=%d;END=%d", r-l-1, r)), v.IVariant.(*vcfgo.Variant).Header)
v2 := parsers.NewVariant(&vcfgo.Variant{Chromosome: v.Chrom(), Pos: uint64(l + 1),
Reference: "A", Alternate: []string{"<DEL>"}, Info_: m}, v.Source(), v.Related())
err = a.AnnotateOne(v2, false, ends)
if err != nil {
log.Println(err)
}
var val interface{}
for _, key := range v2.Info().Keys() {
if key == "SVLEN" || key == "END" {
continue
}
val, err = v2.Info().Get(key)
v.Info().Set(key, val)
}
}
return err
}