Struct googapis::google::genomics::v1::Variant

pub struct Variant {

    pub variant_set_id: String,
    pub id: String,
    pub names: Vec<String>,
    pub created: i64,
    pub reference_name: String,
    pub start: i64,
    pub end: i64,
    pub reference_bases: String,
    pub alternate_bases: Vec<String>,
    pub quality: f64,
    pub filter: Vec<String>,
    pub info: HashMap<String, ListValue>,
    pub calls: Vec<VariantCall>,
}

A variant represents a change in DNA sequence relative to a reference sequence. For example, a variant could represent a SNP or an insertion. Variants belong to a variant set.

For more genomics resource definitions, see Fundamentals of Google Genomics

Each of the calls on a variant represent a determination of genotype with respect to that variant. For example, a call might assign probability of 0.32 to the occurrence of a SNP named rs1234 in a sample named NA12345. A call belongs to a call set, which contains related calls typically from one sample.

Fields

variant_set_id: String

The ID of the variant set this variant belongs to.

id: String

The server-generated variant ID, unique across all variants.

names: Vec<String>

Names for the variant, for example a RefSNP ID.

created: i64

The date this variant was created, in milliseconds from the epoch.

reference_name: String

The reference on which this variant occurs. (such as chr20 or X)

start: i64

The position at which this variant occurs (0-based). This corresponds to the first base of the string of reference bases.

end: i64

The end position (0-based) of this variant. This corresponds to the first base after the last base in the reference allele. So, the length of the reference allele is (end - start). This is useful for variants that don’t explicitly give alternate bases, for example large deletions.

reference_bases: String

The reference bases for this variant. They start at the given position.

alternate_bases: Vec<String>

The bases that appear instead of the reference bases.

quality: f64

A measure of how likely this variant is to be real. A higher value is better.

filter: Vec<String>

A list of filters (normally quality filters) this variant has failed. PASS indicates this variant has passed all filters.

info: HashMap<String, ListValue>

A map of additional variant information. This must be of the form map<string, string[]> (string key mapping to a list of string values).

calls: Vec<VariantCall>

The variant calls for this particular variant. Each one represents the determination of genotype with respect to this variant.

Trait Implementations

impl Clone for Variant

fn clone(&self) -> Variant

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Variant

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Variant

fn default() -> Self

Returns the “default value” for a type.

impl Message for Variant

fn encode_raw<B>(&self, buf: &mut B) where
    B: BufMut, 

fn merge_field<B>(
    &mut self,
    tag: u32,
    wire_type: WireType,
    buf: &mut B,
    ctx: DecodeContext
) -> Result<(), DecodeError> where
    B: Buf, 

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8, Global>

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError> where
    B: BufMut, 

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8, Global>

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError> where
    Self: Default,
    B: Buf, 

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError> where
    B: Buf, 

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq<Variant> for Variant

fn eq(&self, other: &Variant) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Variant) -> bool

This method tests for !=.

impl StructuralPartialEq for Variant