Allele

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

All Implemented Interfaces:

java.lang.Comparable<Allele>
```
public class Allele
extends java.lang.Object
implements java.lang.Comparable<Allele>
```
Immutable representation of an allele Types of alleles: Ref: a t C g a // C is the reference base : a t G g a // C base is a G in some individuals : a t - g a // C base is deleted w.r.t. the reference : a t CAg a // A base is inserted w.r.t. the reference sequence In these cases, where are the alleles? SNP polymorphism of C/G -> { C , G } -> C is the reference allele 1 base deletion of C -> { tC , t } -> C is the reference allele and we include the preceding reference base (null alleles are not allowed) 1 base insertion of A -> { C ; CA } -> C is the reference allele (because null alleles are not allowed) Suppose I see a the following in the population: Ref: a t C g a // C is the reference base : a t G g a // C base is a G in some individuals : a t - g a // C base is deleted w.r.t. the reference How do I represent this? There are three segregating alleles: { C , G , - } and these are represented as: { tC, tG, t } Now suppose I have this more complex example: Ref: a t C g a // C is the reference base : a t - g a : a t - - a : a t CAg a There are actually four segregating alleles: { Cg , -g, --, and CAg } over bases 2-4 represented as: { tCg, tg, t, tCAg } Critically, it should be possible to apply an allele to a reference sequence to create the correct haplotype sequence: Allele + reference => haplotype For convenience, we are going to create Alleles where the GenomeLoc of the allele is stored outside of the Allele object itself. So there's an idea of an A/C polymorphism independent of it's surrounding context. Given list of alleles it's possible to determine the "type" of the variation A / C @ loc => SNP - / A => INDEL If you know where allele is the reference, you can determine whether the variant is an insertion or deletion. Alelle also supports is concept of a NO_CALL allele. This Allele represents a haplotype that couldn't be determined. This is usually represented by a '.' allele. Note that Alleles store all bases as bytes, in **UPPER CASE**. So 'atc' == 'ATC' from the perspective of an Allele.

Field Summary

Fields
Modifier and Type Field and Description

static Allele NO_CALL

static java.lang.String NO_CALL_STRING

Fields
Modifier and Type	Field and Description
`static Allele`	`NO_CALL`
`static java.lang.String`	`NO_CALL_STRING`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Allele(Allele allele, boolean ignoreRefState)` Creates a new allele based on the provided one.
`protected`	`Allele(byte[] bases, boolean isRef)` A generic static NO_CALL allele for use
`protected`	`Allele(java.lang.String bases, boolean isRef)`

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`acceptableAlleleBases(byte[] bases)`
`static boolean`	`acceptableAlleleBases(byte[] bases, boolean allowNsAsAcceptable)`
`static boolean`	`acceptableAlleleBases(java.lang.String bases)`
`static boolean`	`acceptableAlleleBases(java.lang.String bases, boolean allowNsAsAcceptable)`
`boolean`	`basesMatch(Allele test)`
`boolean`	`basesMatch(byte[] test)`
`boolean`	`basesMatch(java.lang.String test)`
`int`	`compareTo(Allele other)`
`static Allele`	`create(Allele allele, boolean ignoreRefState)` Creates a new allele based on the provided one.
`static Allele`	`create(byte base)`
`static Allele`	`create(byte[] bases)` Creates a non-Ref allele.
`static Allele`	`create(byte[] bases, boolean isRef)` Create a new Allele that includes bases and if tagged as the reference allele if isRef == true.
`static Allele`	`create(byte base, boolean isRef)`
`static Allele`	`create(java.lang.String bases)` Creates a non-Ref allele.
`static Allele`	`create(java.lang.String bases, boolean isRef)`
`boolean`	`equals(Allele other, boolean ignoreRefState)` Returns true if this and other are equal.
`boolean`	`equals(java.lang.Object other)`
`static Allele`	`extend(Allele left, byte[] right)`
`byte[]`	`getBases()` Return the DNA bases segregating in this allele.
`java.lang.String`	`getBaseString()` Return the DNA bases segregating in this allele in String format.
`byte[]`	`getDisplayBases()` Same as #getDisplayString() but returns the result as byte[].
`java.lang.String`	`getDisplayString()` Return the printed representation of this allele.
`static Allele`	`getMatchingAllele(java.util.Collection<Allele> allAlleles, byte[] alleleBases)`
`int`	`hashCode()`
`boolean`	`isCalled()`
`boolean`	`isNoCall()`
`boolean`	`isNonReference()`
`boolean`	`isReference()`
`boolean`	`isSymbolic()`
`int`	`length()`
`static boolean`	`oneIsPrefixOfOther(Allele a1, Allele a2)`
`java.lang.String`	`toString()`
`static boolean`	`wouldBeNoCallAllele(byte[] bases)`
`static boolean`	`wouldBeNullAllele(byte[] bases)`
`static boolean`	`wouldBeSymbolicAllele(byte[] bases)`

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

- Field Detail
  - NO_CALL_STRING
```
public static final java.lang.String NO_CALL_STRING
```
    See Also:
    Constant Field Values
  - NO_CALL
```
public static final Allele NO_CALL
```
- Constructor Detail
  - Allele
```
protected Allele(byte[] bases,
      boolean isRef)
```
    A generic static NO_CALL allele for use
  - Allele
```
protected Allele(java.lang.String bases,
      boolean isRef)
```
  - Allele
```
protected Allele(Allele allele,
      boolean ignoreRefState)
```
    Creates a new allele based on the provided one. Ref state will be copied unless ignoreRefState is true (in which case the returned allele will be non-Ref). This method is efficient because it can skip the validation of the bases (since the original allele was already validated)
    
    Parameters:
    allele - the allele from which to copy the bases
    ignoreRefState - should we ignore the reference state of the input allele and use the default ref state?
- Method Detail
  - create
```
public static Allele create(byte[] bases,
            boolean isRef)
```
    Create a new Allele that includes bases and if tagged as the reference allele if isRef == true. If bases == '-', a Null allele is created. If bases == '.', a no call Allele is created.
    
    Parameters:
    bases - the DNA sequence of this variation, '-', of '.'
    isRef - should we make this a reference allele?
    
    Throws:
    
    java.lang.IllegalArgumentException - if bases contains illegal characters or is otherwise malformated
  - create
```
public static Allele create(byte base,
            boolean isRef)
```
  - create
```
public static Allele create(byte base)
```
  - extend
```
public static Allele extend(Allele left,
            byte[] right)
```
  - wouldBeNullAllele
```
public static boolean wouldBeNullAllele(byte[] bases)
```
    Parameters:
    bases - bases representing an allele
    
    Returns:
    true if the bases represent the null allele
  - wouldBeNoCallAllele
```
public static boolean wouldBeNoCallAllele(byte[] bases)
```
    Parameters:
    bases - bases representing an allele
    
    Returns:
    true if the bases represent the NO_CALL allele
  - wouldBeSymbolicAllele
```
public static boolean wouldBeSymbolicAllele(byte[] bases)
```
    Parameters:
    bases - bases representing an allele
    
    Returns:
    true if the bases represent a symbolic allele
  - acceptableAlleleBases
```
public static boolean acceptableAlleleBases(java.lang.String bases)
```
    Parameters:
    bases - bases representing an allele
    
    Returns:
    true if the bases represent the well formatted allele
  - acceptableAlleleBases
```
public static boolean acceptableAlleleBases(java.lang.String bases,
                            boolean allowNsAsAcceptable)
```
  - acceptableAlleleBases
```
public static boolean acceptableAlleleBases(byte[] bases)
```
    Parameters:
    bases - bases representing an allele
    
    Returns:
    true if the bases represent the well formatted allele
  - acceptableAlleleBases
```
public static boolean acceptableAlleleBases(byte[] bases,
                            boolean allowNsAsAcceptable)
```
  - create
```
public static Allele create(java.lang.String bases,
            boolean isRef)
```
    Parameters:
    bases - bases representing an allele
    isRef - is this the reference allele?
    See Also:
    Allele(byte[], boolean)
  - create
```
public static Allele create(java.lang.String bases)
```
    Creates a non-Ref allele. @see Allele(byte[], boolean) for full information
    
    Parameters:
    bases - bases representing an allele
  - create
```
public static Allele create(byte[] bases)
```
    Creates a non-Ref allele. @see Allele(byte[], boolean) for full information
    
    Parameters:
    bases - bases representing an allele
  - create
```
public static Allele create(Allele allele,
            boolean ignoreRefState)
```
    Creates a new allele based on the provided one. Ref state will be copied unless ignoreRefState is true (in which case the returned allele will be non-Ref). This method is efficient because it can skip the validation of the bases (since the original allele was already validated)
    
    Parameters:
    allele - the allele from which to copy the bases
    ignoreRefState - should we ignore the reference state of the input allele and use the default ref state?
  - isNoCall
```
public boolean isNoCall()
```
  - isCalled
```
public boolean isCalled()
```
  - isReference
```
public boolean isReference()
```
  - isNonReference
```
public boolean isNonReference()
```
  - isSymbolic
```
public boolean isSymbolic()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getBases
```
public byte[] getBases()
```
    Return the DNA bases segregating in this allele. Note this isn't reference polarized, so the Null allele is represented by a vector of length 0
    
    Returns:
    the segregating bases
  - getBaseString
```
public java.lang.String getBaseString()
```
    Return the DNA bases segregating in this allele in String format. This is useful, because toString() adds a '*' to reference alleles and getBases() returns garbage when you call toString() on it.
    
    Returns:
    the segregating bases
  - getDisplayString
```
public java.lang.String getDisplayString()
```
    Return the printed representation of this allele. Same as getBaseString(), except for symbolic alleles. For symbolic alleles, the base string is empty while the display string contains .
    
    Returns:
    the allele string representation
  - getDisplayBases
```
public byte[] getDisplayBases()
```
    Same as #getDisplayString() but returns the result as byte[]. Slightly faster then getDisplayString()
    
    Returns:
    the allele string representation
  - equals
```
public boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    other - the other allele
    
    Returns:
    true if these alleles are equal
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    hash code
  - equals
```
public boolean equals(Allele other,
             boolean ignoreRefState)
```
    Returns true if this and other are equal. If ignoreRefState is true, then doesn't require both alleles has the same ref tag
    
    Parameters:
    other - allele to compare to
    ignoreRefState - if true, ignore ref state in comparison
    
    Returns:
    true if this and other are equal
  - basesMatch
```
public boolean basesMatch(byte[] test)
```
    Parameters:
    test - bases to test against
    
    Returns:
    true if this Allele contains the same bases as test, regardless of its reference status; handles Null and NO_CALL alleles
  - basesMatch
```
public boolean basesMatch(java.lang.String test)
```
    Parameters:
    test - bases to test against
    
    Returns:
    true if this Allele contains the same bases as test, regardless of its reference status; handles Null and NO_CALL alleles
  - basesMatch
```
public boolean basesMatch(Allele test)
```
    Parameters:
    test - allele to test against
    
    Returns:
    true if this Allele contains the same bases as test, regardless of its reference status; handles Null and NO_CALL alleles
  - length
```
public int length()
```
    Returns:
    the length of this allele. Null and NO_CALL alleles have 0 length.
  - getMatchingAllele
```
public static Allele getMatchingAllele(java.util.Collection<Allele> allAlleles,
                       byte[] alleleBases)
```
  - compareTo
```
public int compareTo(Allele other)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<Allele>
  - oneIsPrefixOfOther
```
public static boolean oneIsPrefixOfOther(Allele a1,
                         Allele a2)
```

Class Allele

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NO_CALL_STRING

NO_CALL

Constructor Detail

Allele

Allele

Allele

Method Detail

create

create

create

extend

wouldBeNullAllele

wouldBeNoCallAllele

wouldBeSymbolicAllele

acceptableAlleleBases

acceptableAlleleBases

acceptableAlleleBases

acceptableAlleleBases

create

create

create

create

isNoCall

isCalled

isReference

isNonReference

isSymbolic

toString

getBases

getBaseString

getDisplayString

getDisplayBases

equals

hashCode

equals

basesMatch

basesMatch

basesMatch

length

getMatchingAllele

compareTo

oneIsPrefixOfOther