private void fullyDecodeGenotypes (VariantContextBuilder builder, VCFHeader header)
{
GenotypesContext gc = new GenotypesContext ();
foreach (Genotype g in Genotypes) {
gc.Add (fullyDecodeGenotypes (g, header));
}
builder.SetGenotypes (gc, false);
}
/// <summary>
/// the actual constructor. Private access only
/// constructors: see VariantContextBuilder
/// </summary>
/// <param name="source"> source </param>
/// <param name="contig"> the contig </param>
/// <param name="start"> the start base (one based) </param>
/// <param name="stop"> the stop reference base (one based) </param>
/// <param name="alleles"> alleles </param>
/// <param name="genotypes"> genotypes map </param>
/// <param name="log10PError"> qual </param>
/// <param name="filters"> filters: use null for unfiltered and empty set for passes filters </param>
/// <param name="attributes"> attributes </param>
/// <param name="validationToPerform"> set of validation steps to take </param>
protected internal VariantContext (string source, string ID, string contig, long start, long stop, ICollection<Allele> alleles, GenotypesContext genotypes, double log10PError, ISet<string> filters, IDictionary<string, object> attributes, bool fullyDecoded, Validation validationToPerform)
{
if (contig == null) {
throw new System.ArgumentException ("Contig cannot be null");
}
this.contig = contig;
this.start = start;
this.stop = stop;
// intern for efficiency. equals calls will generate NPE if ID is inappropriately passed in as null
if (ID == null || ID.Equals ("")) {
throw new System.ArgumentException ("ID field cannot be the null or the empty string");
}
this.ID = ID.Equals (VCFConstants.EMPTY_ID_FIELD) ? VCFConstants.EMPTY_ID_FIELD : ID;
this.CommonInfo = new CommonInfo (source, log10PError, filters, attributes);
if (alleles == null) {
throw new System.ArgumentException ("Alleles cannot be null");
}
// we need to make this a LinkedHashSet in case the user prefers a given ordering of alleles
this.alleles = makeAlleles (alleles);
if (genotypes == null || genotypes == NO_GENOTYPES) {
this.genotypes = NO_GENOTYPES;
} else {
genotypes.Mutable = false;
this.genotypes = genotypes;
}
// cache the REF and ALT alleles
int nAlleles = alleles.Count;
foreach (Allele a in alleles) {
if (a.Reference) {
REF = a;
} // only cache ALT when biallelic
else if (nAlleles == 2) {
ALT = a;
}
}
this.FullyDecoded = fullyDecoded;
validate (validationToPerform);
}
/// <summary>
/// add a record to the file
/// </summary>
/// <param name="vc"> the Variant Context object </param>
public override void add(VariantContext vc)
{
if (mHeader == null)
{
throw new IllegalStateException("The VCF Header must be written before records can be added: " + StreamName);
}
if (doNotWriteGenotypes)
{
vc = (new VariantContextBuilder(vc)).noGenotypes().make();
}
try
{
base.add(vc);
IDictionary <Allele, string> alleleMap = buildAlleleMap(vc);
// CHROM
write(vc.Chr);
write(VCFConstants.FIELD_SEPARATOR);
// POS
write(Convert.ToString(vc.Start));
write(VCFConstants.FIELD_SEPARATOR);
// ID
string ID = vc.ID;
write(ID);
write(VCFConstants.FIELD_SEPARATOR);
// REF
string refString = vc.Reference.DisplayString;
write(refString);
write(VCFConstants.FIELD_SEPARATOR);
// ALT
if (vc.Variant)
{
Allele altAllele = vc.getAlternateAllele(0);
string alt = altAllele.DisplayString;
write(alt);
for (int i = 1; i < vc.AlternateAlleles.Count; i++)
{
altAllele = vc.getAlternateAllele(i);
alt = altAllele.DisplayString;
write(",");
write(alt);
}
}
else
{
write(VCFConstants.EMPTY_ALTERNATE_ALLELE_FIELD);
}
write(VCFConstants.FIELD_SEPARATOR);
// QUAL
if (!vc.hasLog10PError())
{
write(VCFConstants.MISSING_VALUE_v4);
}
else
{
write(formatQualValue(vc.PhredScaledQual));
}
write(VCFConstants.FIELD_SEPARATOR);
// FILTER
string filters = getFilterString(vc);
write(filters);
write(VCFConstants.FIELD_SEPARATOR);
// INFO
IDictionary <string, string> infoFields = new SortedDictionary <string, string>();
foreach (KeyValuePair <string, object> field in vc.Attributes)
{
string key = field.Key;
if (!mHeader.hasInfoLine(key))
{
fieldIsMissingFromHeaderError(vc, key, "INFO");
}
string outputValue = formatVCFField(field.Value);
if (outputValue != null)
{
infoFields[key] = outputValue;
}
}
writeInfoString(infoFields);
// FORMAT
GenotypesContext gc = vc.Genotypes;
if (gc.LazyWithData && ((LazyGenotypesContext)gc).UnparsedGenotypeData is string)
{
write(VCFConstants.FIELD_SEPARATOR);
write(((LazyGenotypesContext)gc).UnparsedGenotypeData.ToString());
}
else
{
IList <string> genotypeAttributeKeys = calcVCFGenotypeKeys(vc, mHeader);
if (genotypeAttributeKeys.Count > 0)
{
foreach (String format in genotypeAttributeKeys)
{
if (!mHeader.hasFormatLine(format))
{
fieldIsMissingFromHeaderError(vc, format, "FORMAT");
}
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String genotypeFormatString = org.broad.tribble.util.ParsingUtils.join(VCFConstants.GENOTYPE_FIELD_SEPARATOR, genotypeAttributeKeys);
string genotypeFormatString = ParsingUtils.join(VCFConstants.GENOTYPE_FIELD_SEPARATOR, genotypeAttributeKeys);
write(VCFConstants.FIELD_SEPARATOR);
write(genotypeFormatString);
addGenotypeData(vc, alleleMap, genotypeAttributeKeys);
}
}
write("\n");
// note that we cannot call flush here if we want block gzipping to work properly
// calling flush results in all gzipped blocks for each variant
flushBuffer();
}
catch (IOException e)
{
throw new Exception("Unable to write the VCF object to " + StreamName, e);
}
}
/// <summary>
/// Tells this builder that the resulting VariantContext should not contain any GenotypeContext
/// </summary>
public virtual VariantContextBuilder noGenotypes ()
{
this.genotypes_Renamed = null;
return this;
}
/// <summary>
/// Tells this builder that the resulting VariantContext should use this genotypes GenotypeContext
///
/// Note that genotypes can be null -> meaning there are no genotypes
/// </summary>
/// <param name="genotypes"> </param>
public void SetGenotypes (GenotypesContext genotypes, bool requireValidation = true)
{
this.genotypes_Renamed = genotypes;
if (genotypes != null && requireValidation) {
toValidate = toValidate | VariantContext.Validation.GENOTYPES;
}
//TODO: Perhaps if the genotypes are reset we should remove the validation flag if it was not required but was already present?
}
public VariantContextBuilder (VariantContextBuilder parent) : this ()
{
if (parent == null) {
throw new System.ArgumentException ("BUG: VariantContext parent argument cannot be null in VariantContextBuilder");
}
this.alleles_Renamed = parent.alleles_Renamed;
this.attributesCanBeModified = false;
this.Contig = parent.Contig;
this.genotypes_Renamed = parent.genotypes_Renamed;
this.ID = parent.ID;
this.Log10PError = parent.Log10PError;
this.Source = parent.Source;
this.start_Renamed = parent.start_Renamed;
this.stop_Renamed = parent.stop_Renamed;
this.FullyDecoded = parent.FullyDecoded;
this.Attributes = parent.attributes_Renamed;
this.SetFilters (parent.filters_Renamed);
}
/// <summary>
/// Returns a new builder based on parent -- the new VC will have all fields initialized
/// to their corresponding values in parent. This is the best way to create a derived VariantContext
/// </summary>
/// <param name="parent"> Cannot be null </param>
public VariantContextBuilder (VariantContext parent) : this ()
{
if (parent == null) {
throw new System.ArgumentException ("BUG: VariantContextBuilder parent argument cannot be null in VariantContextBuilder");
}
this.alleles_Renamed = parent.alleles;
this.attributes_Renamed = (IDictionary<string,object>)parent.Attributes;
this.attributesCanBeModified = false;
this.Contig = parent.contig;
this.filters_Renamed = (ISet<string>)parent.FiltersMaybeNull;
this.genotypes_Renamed = parent.genotypes;
this.ID = parent.ID;
this.Log10PError = parent.Log10PError;
this.Source = parent.Source;
this.start_Renamed = parent.Start;
this.stop_Renamed = parent.End;
this.FullyDecoded = parent.FullyDecoded;
}
