VariantContext (htsjdk 2.8.1 API)

java.lang.Object
- htsjdk.variant.variantcontext.VariantContext

All Implemented Interfaces:

Locatable, Feature, java.io.Serializable
```
public class VariantContext
extends java.lang.Object
implements Feature, java.io.Serializable
```
High-level overview
The VariantContext object is a single general class system for representing genetic variation data composed of:
- Allele: representing single genetic haplotypes (A, T, ATC, -) (note that null alleles are used here for illustration; see the Allele class for how to represent indels)
- Genotype: an assignment of alleles for each chromosome of a single named sample at a particular locus
- VariantContext: an abstract class holding all segregating alleles at a locus as well as genotypes for multiple individuals containing alleles at that locus
The class system works by defining segregating alleles, creating a variant context representing the segregating information at a locus, and potentially creating and associating genotypes with individuals in the context.

All of the classes are highly validating -- call validate() if you modify them -- so you can rely on the self-consistency of the data once you have a VariantContext in hand. The system has a rich set of assessor and manipulator routines, as well as more complex static support routines in VariantContextUtils.

The VariantContext (and Genotype) objects are attributed (supporting addition of arbitrary key/value pairs) and filtered (can represent a variation that is viewed as suspect).

VariantContexts are dynamically typed, so whether a VariantContext is a SNP, Indel, or NoVariant depends on the properties of the alleles in the context. See the detailed documentation on the Type parameter below.

It's also easy to create subcontexts based on selected genotypes.

Working with Variant Contexts
By default, VariantContexts are immutable. In order to access (in the rare circumstances where you need them) setter routines, you need to create MutableVariantContexts and MutableGenotypes.
Some example data
```
 Allele A, Aref, T, Tref;
 Allele del, delRef, ATC, ATCref;
```
A [ref] / T at 10
```
 
 GenomeLoc snpLoc = GenomeLocParser.createGenomeLoc("chr1", 10, 10);
```
A / ATC [ref] from 20-23
```
 GenomeLoc delLoc = GenomeLocParser.createGenomeLoc("chr1", 20, 22);
```
// A [ref] / ATC immediately after 20
```
 GenomeLoc insLoc = GenomeLocParser.createGenomeLoc("chr1", 20, 20);
```
Alleles
See the documentation in the Allele class itself
What are they?

Alleles can be either reference or non-reference

Examples of alleles used here:
```
   A = new Allele("A");
   Aref = new Allele("A", true);
   T = new Allele("T");
   ATC = new Allele("ATC");
```
Creating variant contexts

By hand
Here's an example of a A/T polymorphism with the A being reference:
```
 VariantContext vc = new VariantContext(name, snpLoc, Arrays.asList(Aref, T));
 
```
If you want to create a non-variant site, just put in a single reference allele
```
 VariantContext vc = new VariantContext(name, snpLoc, Arrays.asList(Aref));
 
```
A deletion is just as easy:
```
 VariantContext vc = new VariantContext(name, delLoc, Arrays.asList(ATCref, del));
 
```
The only thing that distinguishes between an insertion and deletion is which is the reference allele. An insertion has a reference allele that is smaller than the non-reference allele, and vice versa for deletions.
```
 VariantContext vc = new VariantContext("name", insLoc, Arrays.asList(delRef, ATC));
 
```
Converting rods and other data structures to VariantContexts
You can convert many common types into VariantContexts using the general function:
```
 VariantContextAdaptors.convertToVariantContext(name, myObject)
 
```
dbSNP and VCFs, for example, can be passed in as myObject and a VariantContext corresponding to that object will be returned. A null return value indicates that the type isn't yet supported. This is the best and easiest way to create contexts using RODs.
Working with genotypes
```
 List<Allele> alleles = Arrays.asList(Aref, T);
 Genotype g1 = new Genotype(Arrays.asList(Aref, Aref), "g1", 10);
 Genotype g2 = new Genotype(Arrays.asList(Aref, T), "g2", 10);
 Genotype g3 = new Genotype(Arrays.asList(T, T), "g3", 10);
 VariantContext vc = new VariantContext(snpLoc, alleles, Arrays.asList(g1, g2, g3));
 
```
At this point we have 3 genotypes in our context, g1-g3. You can assess a good deal of information about the genotypes through the VariantContext:
```
 vc.hasGenotypes()
 vc.isMonomorphicInSamples()
 vc.isPolymorphicInSamples()
 vc.getSamples().size()

 vc.getGenotypes()
 vc.getGenotypes().get("g1")
 vc.hasGenotype("g1")

 vc.getCalledChrCount()
 vc.getCalledChrCount(Aref)
 vc.getCalledChrCount(T)
 
```
NO_CALL alleles
The system allows one to create Genotypes carrying special NO_CALL alleles that aren't present in the set of context alleles and that represent undetermined alleles in a genotype:
```
 Genotype g4 = new Genotype(Arrays.asList(Allele.NO_CALL, Allele.NO_CALL), "NO_DATA_FOR_SAMPLE", 10);
```
subcontexts
It's also very easy get subcontext based only the data in a subset of the genotypes:
```
 VariantContext vc12 = vc.subContextFromGenotypes(Arrays.asList(g1,g2));
 VariantContext vc1 = vc.subContextFromGenotypes(Arrays.asList(g1));
 
```
Fully decoding.
Currently VariantContexts support some fields, particularly those stored as generic attributes, to be of any type. For example, a field AB might be naturally a floating point number, 0.51, but when it's read into a VC its not decoded into the Java presentation but left as a string "0.51". A fully decoded VariantContext is one where all values have been converted to their corresponding Java object types, based on the types declared in a VCFHeader. The fullyDecode(...) method takes a header object and creates a new fully decoded VariantContext where all fields are converted to their true java representation. The VCBuilder can be told that all fields are fully decoded, in which case no work is done when asking for a fully decoded version of the VC.
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class VariantContext.Type

static class VariantContext.Validation

Nested Classes
Modifier and Type	Class and Description
`static class`	`VariantContext.Type`
`static class`	`VariantContext.Validation`

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.List<Allele>`	`alleles` A set of the alleles segregating in this context
`protected CommonInfo`	`commonInfo`
`protected java.lang.String`	`contig` The location of this VariantContext
`protected int[]`	`genotypeCounts` Counts for each of the possible Genotype types in this context
`protected GenotypesContext`	`genotypes` A mapping from sampleName -> genotype objects for all genotypes associated with this context
`static GenotypesContext`	`NO_GENOTYPES`
`static double`	`NO_LOG10_PERROR`
`static java.util.Set<java.lang.String>`	`PASSES_FILTERS`
`static long`	`serialVersionUID`
`protected long`	`start`
`protected long`	`stop`
`protected VariantContext.Type`	`type` The type (cached for performance reasons) of this context

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`VariantContext(java.lang.String source, java.lang.String ID, java.lang.String contig, long start, long stop, java.util.Collection<Allele> alleles, GenotypesContext genotypes, double log10PError, java.util.Set<java.lang.String> filters, java.util.Map<java.lang.String,java.lang.Object> attributes, boolean fullyDecoded, java.util.EnumSet<VariantContext.Validation> validationToPerform)` the actual constructor.
`protected`	`VariantContext(VariantContext other)` Copy constructor

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.util.List<java.lang.String>`	`calcVCFGenotypeKeys(VCFHeader header)`
`boolean`	`emptyID()`
`void`	`extraStrictValidation(Allele reportedReference, Allele observedReference, java.util.Set<java.lang.String> rsIDs)` Run all extra-strict validation tests on a Variant Context object
`boolean`	`filtersWereApplied()`
`VariantContext`	`fullyDecode(VCFHeader header, boolean lenientDecoding)` Return a VC equivalent to this one but where all fields are fully decoded See VariantContext document about fully decoded
`Allele`	`getAllele(byte[] allele)`
`Allele`	`getAllele(java.lang.String allele)`
`int`	`getAlleleIndex(Allele allele)` Lookup the index of allele in this variant context
`java.util.List<java.lang.Integer>`	`getAlleleIndices(java.util.Collection<Allele> alleles)` Return the allele index #getAlleleIndex for each allele in alleles
`java.util.List<Allele>`	`getAlleles()` Gets the alleles.
`Allele`	`getAltAlleleWithHighestAlleleCount()`
`Allele`	`getAlternateAllele(int i)`
`java.util.List<Allele>`	`getAlternateAlleles()` Gets the alternate alleles.
`java.lang.Object`	`getAttribute(java.lang.String key)`
`java.lang.Object`	`getAttribute(java.lang.String key, java.lang.Object defaultValue)`
`boolean`	`getAttributeAsBoolean(java.lang.String key, boolean defaultValue)`
`double`	`getAttributeAsDouble(java.lang.String key, double defaultValue)`
`java.util.List<java.lang.Double>`	`getAttributeAsDoubleList(java.lang.String key, double defaultValue)`
`int`	`getAttributeAsInt(java.lang.String key, int defaultValue)`
`java.util.List<java.lang.Integer>`	`getAttributeAsIntList(java.lang.String key, int defaultValue)`
`java.util.List<java.lang.Object>`	`getAttributeAsList(java.lang.String key)` returns the value as an empty list if the key was not found, as a java.util.List if the value is a List or an Array, as a Collections.singletonList if there is only one value
`java.lang.String`	`getAttributeAsString(java.lang.String key, java.lang.String defaultValue)`
`java.util.List<java.lang.String>`	`getAttributeAsStringList(java.lang.String key, java.lang.String defaultValue)`
`java.util.Map<java.lang.String,java.lang.Object>`	`getAttributes()`
`int`	`getCalledChrCount()` Returns the number of chromosomes carrying any allele in the genotypes (i.e., excluding NO_CALLS)
`int`	`getCalledChrCount(Allele a)` Returns the number of chromosomes carrying allele A in the genotypes
`int`	`getCalledChrCount(Allele a, java.util.Set<java.lang.String> sampleIds)` Returns the number of chromosomes carrying allele A in the genotypes
`int`	`getCalledChrCount(java.util.Set<java.lang.String> sampleIds)` Returns the number of chromosomes carrying any allele in the genotypes (i.e., excluding NO_CALLS)
`CommonInfo`	`getCommonInfo()`
`java.lang.String`	`getContig()` Gets the contig name for the contig this is mapped to.
`int`	`getEnd()`
`java.util.Set<java.lang.String>`	`getFilters()`
`java.util.Set<java.lang.String>`	`getFiltersMaybeNull()`
`Genotype`	`getGenotype(int ith)`
`Genotype`	`getGenotype(java.lang.String sample)`
`GenotypesContext`	`getGenotypes()`
`protected GenotypesContext`	`getGenotypes(java.util.Collection<java.lang.String> sampleNames)` Returns a map from sampleName -> Genotype for each sampleName in sampleNames.
`GenotypesContext`	`getGenotypes(java.util.Set<java.lang.String> sampleNames)`
`GenotypesContext`	`getGenotypes(java.lang.String sampleName)` Returns a map from sampleName -> Genotype for the genotype associated with sampleName.
`java.lang.Iterable<Genotype>`	`getGenotypesOrderedBy(java.lang.Iterable<java.lang.String> sampleOrdering)`
`java.lang.Iterable<Genotype>`	`getGenotypesOrderedByName()`
`int[]`	`getGLIndecesOfAlternateAllele(Allele targetAllele)`
`int`	`getHetCount()` Genotype-specific functions -- how many het calls are there in the genotypes?
`int`	`getHomRefCount()` Genotype-specific functions -- how many hom ref calls are there in the genotypes?
`int`	`getHomVarCount()` Genotype-specific functions -- how many hom var calls are there in the genotypes?
`java.lang.String`	`getID()`
`java.util.List<java.lang.Integer>`	`getIndelLengths()` Gets the sizes of the alternate alleles if they are insertion/deletion events, and returns a list of their sizes
`double`	`getLog10PError()`
`int`	`getMaxPloidy(int defaultPloidy)` Returns the maximum ploidy of all samples in this VC, or default if there are no genotypes This function is caching, so it's only expensive on the first call
`int`	`getMixedCount()` Genotype-specific functions -- how many mixed calls are there in the genotypes?
`int`	`getNAlleles()`
`int`	`getNoCallCount()` Genotype-specific functions -- how many no-calls are there in the genotypes?
`int`	`getNSamples()`
`double`	`getPhredScaledQual()`
`Allele`	`getReference()`
`java.util.Set<java.lang.String>`	`getSampleNames()`
`java.util.List<java.lang.String>`	`getSampleNamesOrderedByName()`
`java.lang.String`	`getSource()`
`int`	`getStart()`
`StructuralVariantType`	`getStructuralVariantType()` Search for the INFO=SVTYPE and return the type of Structural Variant
`VariantContext.Type`	`getType()` Determines (if necessary) and returns the type of this variation by examining the alleles it contains.
`boolean`	`hasAllele(Allele allele)`
`boolean`	`hasAllele(Allele allele, boolean ignoreRefState)`
`boolean`	`hasAlternateAllele(Allele allele)`
`boolean`	`hasAlternateAllele(Allele allele, boolean ignoreRefState)`
`boolean`	`hasAttribute(java.lang.String key)`
`boolean`	`hasGenotype(java.lang.String sample)`
`boolean`	`hasGenotypes()`
`boolean`	`hasGenotypes(java.util.Collection<java.lang.String> sampleNames)`
`boolean`	`hasID()`
`boolean`	`hasLog10PError()`
`boolean`	`hasSameAllelesAs(VariantContext other)`
`boolean`	`hasSameAlternateAllelesAs(VariantContext other)`
`boolean`	`hasSymbolicAlleles()`
`static boolean`	`hasSymbolicAlleles(java.util.List<Allele> alleles)`
`boolean`	`isBiallelic()`
`boolean`	`isComplexIndel()`
`boolean`	`isFiltered()`
`boolean`	`isFullyDecoded()` See VariantContext document about fully decoded
`boolean`	`isIndel()` convenience method for indels
`boolean`	`isMixed()` convenience method for indels
`boolean`	`isMNP()`
`boolean`	`isMonomorphicInSamples()` Genotype-specific functions -- are the genotypes monomorphic w.r.t.
`boolean`	`isNotFiltered()`
`boolean`	`isPointEvent()` convenience method for point events
`boolean`	`isPolymorphicInSamples()` Genotype-specific functions -- are the genotypes polymorphic w.r.t.
`boolean`	`isSimpleDeletion()`
`boolean`	`isSimpleIndel()`
`boolean`	`isSimpleInsertion()`
`boolean`	`isSNP()` convenience method for SNPs
`boolean`	`isStructuralIndel()`
`boolean`	`isSymbolic()`
`boolean`	`isSymbolicOrSV()`
`boolean`	`isVariant()` convenience method for variants
`VariantContext`	`subContextFromSample(java.lang.String sampleName)`
`VariantContext`	`subContextFromSamples(java.util.Set<java.lang.String> sampleNames)`
`VariantContext`	`subContextFromSamples(java.util.Set<java.lang.String> sampleNames, boolean rederiveAllelesFromGenotypes)` This method subsets down to a set of samples.
`java.lang.String`	`toString()`
`java.lang.String`	`toStringDecodeGenotypes()`
`java.lang.String`	`toStringWithoutGenotypes()`
`void`	`validateAlternateAlleles()`
`void`	`validateChromosomeCounts()`
`void`	`validateReferenceBases(Allele reportedReference, Allele observedReference)`
`void`	`validateRSIDs(java.util.Set<java.lang.String> rsIDs)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface htsjdk.tribble.Feature
getChr

- Field Detail
  - serialVersionUID
```
public static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - commonInfo
```
protected CommonInfo commonInfo
```
  - NO_LOG10_PERROR
```
public static final double NO_LOG10_PERROR
```
    See Also:
    
    Constant Field Values
  - PASSES_FILTERS
```
public static final java.util.Set<java.lang.String> PASSES_FILTERS
```
  - contig
```
protected final java.lang.String contig
```
    The location of this VariantContext
  - start
```
protected final long start
```
  - stop
```
protected final long stop
```
  - type
```
protected VariantContext.Type type
```
    The type (cached for performance reasons) of this context
  - alleles
```
protected final java.util.List<Allele> alleles
```
    A set of the alleles segregating in this context
  - genotypes
```
protected GenotypesContext genotypes
```
    A mapping from sampleName -> genotype objects for all genotypes associated with this context
  - genotypeCounts
```
protected int[] genotypeCounts
```
    Counts for each of the possible Genotype types in this context
  - NO_GENOTYPES
```
public static final GenotypesContext NO_GENOTYPES
```
- Constructor Detail
  - VariantContext
```
protected VariantContext(VariantContext other)
```
    Copy constructor
    
    Parameters:
    
    other - the VariantContext to copy
  - VariantContext
```
protected VariantContext(java.lang.String source,
                         java.lang.String ID,
                         java.lang.String contig,
                         long start,
                         long stop,
                         java.util.Collection<Allele> alleles,
                         GenotypesContext genotypes,
                         double log10PError,
                         java.util.Set<java.lang.String> filters,
                         java.util.Map<java.lang.String,java.lang.Object> attributes,
                         boolean fullyDecoded,
                         java.util.EnumSet<VariantContext.Validation> validationToPerform)
```
    the actual constructor. Private access only
    
    Parameters:
    
    source - source
    
    contig - the contig
    
    start - the start base (one based)
    
    stop - the stop reference base (one based)
    
    alleles - alleles
    
    genotypes - genotypes map
    
    log10PError - qual
    
    filters - filters: use null for unfiltered and empty set for passes filters
    
    attributes - attributes
    
    validationToPerform - set of validation steps to take
- Method Detail
  - calcVCFGenotypeKeys
```
public java.util.List<java.lang.String> calcVCFGenotypeKeys(VCFHeader header)
```
  - subContextFromSamples
```
public VariantContext subContextFromSamples(java.util.Set<java.lang.String> sampleNames,
                                            boolean rederiveAllelesFromGenotypes)
```
    This method subsets down to a set of samples. At the same time returns the alleles to just those in use by the samples, if rederiveAllelesFromGenotypes is true, otherwise the full set of alleles in this VC is returned as the set of alleles in the subContext, even if some of those alleles aren't in the samples WARNING: BE CAREFUL WITH rederiveAllelesFromGenotypes UNLESS YOU KNOW WHAT YOU ARE DOING
    
    Parameters:
    
    sampleNames - the sample names
    
    rederiveAllelesFromGenotypes - if true, returns the alleles to just those in use by the samples, true should be default
    
    Returns:
    
    new VariantContext subsetting to just the given samples
  - subContextFromSamples
```
public VariantContext subContextFromSamples(java.util.Set<java.lang.String> sampleNames)
```
    Parameters:
    
    sampleNames -
    
    Returns:
    
    See Also:
    
    with rederiveAllelesFromGenotypes = true
  - subContextFromSample
```
public VariantContext subContextFromSample(java.lang.String sampleName)
```
  - getType
```
public VariantContext.Type getType()
```
    Determines (if necessary) and returns the type of this variation by examining the alleles it contains.
    
    Returns:
    
    the type of this VariantContext
  - isSNP
```
public boolean isSNP()
```
    convenience method for SNPs
    
    Returns:
    
    true if this is a SNP, false otherwise
  - isVariant
```
public boolean isVariant()
```
    convenience method for variants
    
    Returns:
    
    true if this is a variant allele, false if it's reference
  - isPointEvent
```
public boolean isPointEvent()
```
    convenience method for point events
    
    Returns:
    
    true if this is a SNP or ref site, false if it's an indel or mixed event
  - isIndel
```
public boolean isIndel()
```
    convenience method for indels
    
    Returns:
    
    true if this is an indel, false otherwise
  - isSimpleInsertion
```
public boolean isSimpleInsertion()
```
    Returns:
    
    true if the alleles indicate a simple insertion (i.e., the reference allele is Null)
  - isSimpleDeletion
```
public boolean isSimpleDeletion()
```
    Returns:
    
    true if the alleles indicate a simple deletion (i.e., a single alt allele that is Null)
  - isSimpleIndel
```
public boolean isSimpleIndel()
```
    Returns:
    
    true if the alleles indicate a simple indel, false otherwise.
  - isComplexIndel
```
public boolean isComplexIndel()
```
    Returns:
    
    true if the alleles indicate neither a simple deletion nor a simple insertion
  - isSymbolic
```
public boolean isSymbolic()
```
  - isStructuralIndel
```
public boolean isStructuralIndel()
```
  - isSymbolicOrSV
```
public boolean isSymbolicOrSV()
```
    Returns:
    
    true if the variant is symbolic or a large indel
  - isMNP
```
public boolean isMNP()
```
  - isMixed
```
public boolean isMixed()
```
    convenience method for indels
    
    Returns:
    
    true if this is an mixed variation, false otherwise
  - hasID
```
public boolean hasID()
```
  - emptyID
```
public boolean emptyID()
```
  - getID
```
public java.lang.String getID()
```
  - getSource
```
public java.lang.String getSource()
```
  - getFiltersMaybeNull
```
public java.util.Set<java.lang.String> getFiltersMaybeNull()
```
  - getFilters
```
public java.util.Set<java.lang.String> getFilters()
```
  - isFiltered
```
public boolean isFiltered()
```
  - isNotFiltered
```
public boolean isNotFiltered()
```
  - filtersWereApplied
```
public boolean filtersWereApplied()
```
  - hasLog10PError
```
public boolean hasLog10PError()
```
  - getLog10PError
```
public double getLog10PError()
```
  - getPhredScaledQual
```
public double getPhredScaledQual()
```
  - getAttributes
```
public java.util.Map<java.lang.String,java.lang.Object> getAttributes()
```
  - hasAttribute
```
public boolean hasAttribute(java.lang.String key)
```
  - getAttribute
```
public java.lang.Object getAttribute(java.lang.String key)
```
  - getAttribute
```
public java.lang.Object getAttribute(java.lang.String key,
                                     java.lang.Object defaultValue)
```
  - getAttributeAsString
```
public java.lang.String getAttributeAsString(java.lang.String key,
                                             java.lang.String defaultValue)
```
  - getAttributeAsInt
```
public int getAttributeAsInt(java.lang.String key,
                             int defaultValue)
```
  - getAttributeAsDouble
```
public double getAttributeAsDouble(java.lang.String key,
                                   double defaultValue)
```
  - getAttributeAsBoolean
```
public boolean getAttributeAsBoolean(java.lang.String key,
                                     boolean defaultValue)
```
  - getAttributeAsList
```
public java.util.List<java.lang.Object> getAttributeAsList(java.lang.String key)
```
    returns the value as an empty list if the key was not found, as a java.util.List if the value is a List or an Array, as a Collections.singletonList if there is only one value
  - getAttributeAsStringList
```
public java.util.List<java.lang.String> getAttributeAsStringList(java.lang.String key,
                                                                 java.lang.String defaultValue)
```
  - getAttributeAsIntList
```
public java.util.List<java.lang.Integer> getAttributeAsIntList(java.lang.String key,
                                                               int defaultValue)
```
  - getAttributeAsDoubleList
```
public java.util.List<java.lang.Double> getAttributeAsDoubleList(java.lang.String key,
                                                                 double defaultValue)
```
  - getCommonInfo
```
public CommonInfo getCommonInfo()
```
  - getReference
```
public Allele getReference()
```
    Returns:
    
    the reference allele for this context
  - isBiallelic
```
public boolean isBiallelic()
```
    Returns:
    
    true if the context is strictly bi-allelic
  - getNAlleles
```
public int getNAlleles()
```
    Returns:
    
    The number of segregating alleles in this context
  - getMaxPloidy
```
public int getMaxPloidy(int defaultPloidy)
```
    Returns the maximum ploidy of all samples in this VC, or default if there are no genotypes This function is caching, so it's only expensive on the first call
    
    Parameters:
    
    defaultPloidy - the default ploidy, if all samples are no-called
    
    Returns:
    
    default, or the max ploidy
  - getAllele
```
public Allele getAllele(java.lang.String allele)
```
    Returns:
    
    The allele sharing the same bases as this String. A convenience method; better to use byte[]
  - getAllele
```
public Allele getAllele(byte[] allele)
```
    Returns:
    
    The allele sharing the same bases as this byte[], or null if no such allele is present.
  - hasAllele
```
public boolean hasAllele(Allele allele)
```
    Returns:
    
    True if this context contains Allele allele, or false otherwise
  - hasAllele
```
public boolean hasAllele(Allele allele,
                         boolean ignoreRefState)
```
  - hasAlternateAllele
```
public boolean hasAlternateAllele(Allele allele)
```
  - hasAlternateAllele
```
public boolean hasAlternateAllele(Allele allele,
                                  boolean ignoreRefState)
```
  - getAlleles
```
public java.util.List<Allele> getAlleles()
```
    Gets the alleles. This method should return all of the alleles present at the location, including the reference allele. There are no constraints imposed on the ordering of alleles in the set. If the reference is not an allele in this context it will not be included.
    
    Returns:
    
    the set of alleles
  - getAlternateAlleles
```
public java.util.List<Allele> getAlternateAlleles()
```
    Gets the alternate alleles. This method should return all the alleles present at the location, NOT including the reference allele. There are no constraints imposed on the ordering of alleles in the set.
    
    Returns:
    
    the set of alternate alleles
  - getIndelLengths
```
public java.util.List<java.lang.Integer> getIndelLengths()
```
    Gets the sizes of the alternate alleles if they are insertion/deletion events, and returns a list of their sizes
    
    Returns:
    
    a list of indel lengths ( null if not of type indel or mixed )
  - getAlternateAllele
```
public Allele getAlternateAllele(int i)
```
    Parameters:
    
    i - -- the ith allele (from 0 to n - 2 for a context with n alleles including a reference allele)
    
    Returns:
    
    the ith non-reference allele in this context
    
    Throws:
    
    java.lang.IllegalArgumentException - if i is invalid
  - hasSameAllelesAs
```
public boolean hasSameAllelesAs(VariantContext other)
```
    Parameters:
    
    other - VariantContext whose alleles to compare against
    
    Returns:
    
    true if this VariantContext has the same alleles (both ref and alts) as other, regardless of ordering. Otherwise returns false.
  - hasSameAlternateAllelesAs
```
public boolean hasSameAlternateAllelesAs(VariantContext other)
```
    Parameters:
    
    other - VariantContext whose alternate alleles to compare against
    
    Returns:
    
    true if this VariantContext has the same alternate alleles as other, regardless of ordering. Otherwise returns false.
  - getNSamples
```
public int getNSamples()
```
    Returns:
    
    the number of samples in the context
  - hasGenotypes
```
public boolean hasGenotypes()
```
    Returns:
    
    true if the context has associated genotypes
  - hasGenotypes
```
public boolean hasGenotypes(java.util.Collection<java.lang.String> sampleNames)
```
  - getGenotypes
```
public GenotypesContext getGenotypes()
```
    Returns:
    
    set of all Genotypes associated with this context
  - getGenotypesOrderedByName
```
public java.lang.Iterable<Genotype> getGenotypesOrderedByName()
```
  - getGenotypesOrderedBy
```
public java.lang.Iterable<Genotype> getGenotypesOrderedBy(java.lang.Iterable<java.lang.String> sampleOrdering)
```
  - getGenotypes
```
public GenotypesContext getGenotypes(java.lang.String sampleName)
```
    Returns a map from sampleName -> Genotype for the genotype associated with sampleName. Returns a map for consistency with the multi-get function.
    
    Parameters:
    
    sampleName - the sample name
    
    Returns:
    
    mapping from sample name to genotype
    
    Throws:
    
    java.lang.IllegalArgumentException - if sampleName isn't bound to a genotype
  - getGenotypes
```
protected GenotypesContext getGenotypes(java.util.Collection<java.lang.String> sampleNames)
```
    Returns a map from sampleName -> Genotype for each sampleName in sampleNames. Returns a map for consistency with the multi-get function. For testing convenience only
    
    Parameters:
    
    sampleNames - a unique list of sample names
    
    Returns:
    
    subsetting genotypes context
    
    Throws:
    
    java.lang.IllegalArgumentException - if sampleName isn't bound to a genotype
  - getGenotypes
```
public GenotypesContext getGenotypes(java.util.Set<java.lang.String> sampleNames)
```
  - getSampleNames
```
public java.util.Set<java.lang.String> getSampleNames()
```
    Returns:
    
    the set of all sample names in this context, not ordered
  - getSampleNamesOrderedByName
```
public java.util.List<java.lang.String> getSampleNamesOrderedByName()
```
  - getGenotype
```
public Genotype getGenotype(java.lang.String sample)
```
    Parameters:
    
    sample - the sample name
    
    Returns:
    
    the Genotype associated with the given sample in this context or null if the sample is not in this context
  - hasGenotype
```
public boolean hasGenotype(java.lang.String sample)
```
  - getGenotype
```
public Genotype getGenotype(int ith)
```
    Parameters:
    
    ith - the sample index
    
    Returns:
    
    the ith genotype in this context or null if there aren't that many genotypes
  - getCalledChrCount
```
public int getCalledChrCount()
```
    Returns the number of chromosomes carrying any allele in the genotypes (i.e., excluding NO_CALLS)
    
    Returns:
    
    chromosome count
  - getCalledChrCount
```
public int getCalledChrCount(java.util.Set<java.lang.String> sampleIds)
```
    Returns the number of chromosomes carrying any allele in the genotypes (i.e., excluding NO_CALLS)
    
    Parameters:
    
    sampleIds - IDs of samples to take into account. If empty then all samples are included.
    
    Returns:
    
    chromosome count
  - getCalledChrCount
```
public int getCalledChrCount(Allele a)
```
    Returns the number of chromosomes carrying allele A in the genotypes
    
    Parameters:
    
    a - allele
    
    Returns:
    
    chromosome count
  - getCalledChrCount
```
public int getCalledChrCount(Allele a,
                             java.util.Set<java.lang.String> sampleIds)
```
    Returns the number of chromosomes carrying allele A in the genotypes
    
    Parameters:
    
    a - allele
    
    sampleIds - - IDs of samples to take into account. If empty then all samples are included.
    
    Returns:
    
    chromosome count
  - isMonomorphicInSamples
```
public boolean isMonomorphicInSamples()
```
    Genotype-specific functions -- are the genotypes monomorphic w.r.t. to the alleles segregating at this site? That is, is the number of alternate alleles among all fo the genotype == 0?
    
    Returns:
    
    true if it's monomorphic
  - isPolymorphicInSamples
```
public boolean isPolymorphicInSamples()
```
    Genotype-specific functions -- are the genotypes polymorphic w.r.t. to the alleles segregating at this site? That is, is the number of alternate alleles among all fo the genotype > 0?
    
    Returns:
    
    true if it's polymorphic
  - getNoCallCount
```
public int getNoCallCount()
```
    Genotype-specific functions -- how many no-calls are there in the genotypes?
    
    Returns:
    
    number of no calls
  - getHomRefCount
```
public int getHomRefCount()
```
    Genotype-specific functions -- how many hom ref calls are there in the genotypes?
    
    Returns:
    
    number of hom ref calls
  - getHetCount
```
public int getHetCount()
```
    Genotype-specific functions -- how many het calls are there in the genotypes?
    
    Returns:
    
    number of het calls
  - getHomVarCount
```
public int getHomVarCount()
```
    Genotype-specific functions -- how many hom var calls are there in the genotypes?
    
    Returns:
    
    number of hom var calls
  - getMixedCount
```
public int getMixedCount()
```
    Genotype-specific functions -- how many mixed calls are there in the genotypes?
    
    Returns:
    
    number of mixed calls
  - extraStrictValidation
```
public void extraStrictValidation(Allele reportedReference,
                                  Allele observedReference,
                                  java.util.Set<java.lang.String> rsIDs)
```
    Run all extra-strict validation tests on a Variant Context object
    
    Parameters:
    
    reportedReference - the reported reference allele
    
    observedReference - the observed reference allele
    
    rsIDs - the true dbSNP IDs
  - validateReferenceBases
```
public void validateReferenceBases(Allele reportedReference,
                                   Allele observedReference)
```
  - validateRSIDs
```
public void validateRSIDs(java.util.Set<java.lang.String> rsIDs)
```
  - validateAlternateAlleles
```
public void validateAlternateAlleles()
```
  - validateChromosomeCounts
```
public void validateChromosomeCounts()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toStringDecodeGenotypes
```
public java.lang.String toStringDecodeGenotypes()
```
  - toStringWithoutGenotypes
```
public java.lang.String toStringWithoutGenotypes()
```
  - fullyDecode
```
public VariantContext fullyDecode(VCFHeader header,
                                  boolean lenientDecoding)
```
    Return a VC equivalent to this one but where all fields are fully decoded See VariantContext document about fully decoded
    
    Parameters:
    
    header - containing types about all fields in this VC
    
    Returns:
    
    a fully decoded version of this VC
  - isFullyDecoded
```
public boolean isFullyDecoded()
```
    See VariantContext document about fully decoded
    
    Returns:
    
    true if this is a fully decoded VC
  - getContig
```
public java.lang.String getContig()
```
    Description copied from interface: Locatable
    
    Gets the contig name for the contig this is mapped to. May return null if there is no unique mapping.
    
    Specified by:
    
    getContig in interface Locatable
    
    Returns:
    
    name of the contig this is mapped to, potentially null
  - getStart
```
public int getStart()
```
    Specified by:
    
    getStart in interface Locatable
    
    Returns:
    
    1-based inclusive start position of the Variant INDEL events usually start on the first unaltered reference base before the INDEL Warning: be aware that the start position of the VariantContext is defined in terms of the start position specified in the underlying vcf file, VariantContexts representing the same biological event may have different start positions depending on the specifics of the vcf file they are derived from
  - getEnd
```
public int getEnd()
```
    Specified by:
    
    getEnd in interface Locatable
    
    Returns:
    
    1-based closed end position of the Variant If the END info field is specified that value is returned, otherwise the end is the start + reference allele length - 1. For VariantContexts with a single alternate allele, if that allele is an insertion, the end position will be on the reference base before the insertion event. If the single alt allele is a deletion, the end will be on the final deleted reference base.
  - hasSymbolicAlleles
```
public boolean hasSymbolicAlleles()
```
  - hasSymbolicAlleles
```
public static boolean hasSymbolicAlleles(java.util.List<Allele> alleles)
```
  - getAltAlleleWithHighestAlleleCount
```
public Allele getAltAlleleWithHighestAlleleCount()
```
  - getAlleleIndex
```
public int getAlleleIndex(Allele allele)
```
    Lookup the index of allele in this variant context
    
    Parameters:
    
    allele - the allele whose index we want to get
    
    Returns:
    
    the index of the allele into getAlleles(), or -1 if it cannot be found
  - getAlleleIndices
```
public java.util.List<java.lang.Integer> getAlleleIndices(java.util.Collection<Allele> alleles)
```
    Return the allele index #getAlleleIndex for each allele in alleles
    
    Parameters:
    
    alleles - the alleles we want to look up
    
    Returns:
    
    a list of indices for each allele, in order
  - getGLIndecesOfAlternateAllele
```
public int[] getGLIndecesOfAlternateAllele(Allele targetAllele)
```
  - getStructuralVariantType
```
public StructuralVariantType getStructuralVariantType()
```
    Search for the INFO=SVTYPE and return the type of Structural Variant
    
    Returns:
    
    the StructuralVariantType of null if there is no property SVTYPE

Class VariantContext

High-level overview

Working with Variant Contexts

Some example data

Alleles

What are they?

Creating variant contexts

By hand

Converting rods and other data structures to VariantContexts

Working with genotypes

NO_CALL alleles

subcontexts

Fully decoding.

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface htsjdk.tribble.Feature

Field Detail

serialVersionUID

commonInfo

NO_LOG10_PERROR

PASSES_FILTERS

contig

start

stop

type

alleles

genotypes

genotypeCounts

NO_GENOTYPES

Constructor Detail

VariantContext

VariantContext

Method Detail

calcVCFGenotypeKeys

subContextFromSamples

subContextFromSamples

subContextFromSample

getType

isSNP

isVariant

isPointEvent

isIndel

isSimpleInsertion

isSimpleDeletion

isSimpleIndel

isComplexIndel

isSymbolic

isStructuralIndel

isSymbolicOrSV

isMNP

isMixed

hasID

emptyID

getID

getSource

getFiltersMaybeNull

getFilters

isFiltered

isNotFiltered

filtersWereApplied

hasLog10PError

getLog10PError

getPhredScaledQual

getAttributes

hasAttribute

getAttribute

getAttribute

getAttributeAsString

getAttributeAsInt

getAttributeAsDouble

getAttributeAsBoolean

getAttributeAsList

getAttributeAsStringList

getAttributeAsIntList

getAttributeAsDoubleList

getCommonInfo

getReference

Converting rods and other data structures to `VariantContext`s