Struct hpo::annotations::Gene

pub struct Gene { /* private fields */ }

A single gene

A gene has a unique GeneId and a name (symbol) and is connected to a set of HPO terms

Implementations

impl Gene

pub fn new(id: GeneId, name: &str) -> Gene

Initializes a new Gene

This method should rarely, if ever, be used directly. The preferred way to create new genes is through Ontology::add_gene to ensure that each gene exists only once.

pub fn from_parts(id: &str, name: &str) -> HpoResult<Gene>

Initializes a new Gene from str values

This method should rarely, if ever, be used directly. The preferred way to create new genes is through Ontology::add_gene to ensure that each gene exists only once.

Errors

If the id is not a correct GeneId, returns HpoError::ParseIntError

pub fn id(&self) -> &GeneId

The unique GeneId of the gene, most likely the NCBI Gene ID

pub fn name(&self) -> &str

The name of the gene (gene symbol)

pub fn symbol(&self) -> &str

The gene symbol (identical to Gene::id)

pub fn add_term<I: Into<HpoTermId>>(&mut self, term_id: I) -> bool

Connect another HPO term to the gene

pub fn hpo_terms(&self) -> &HpoGroup

The set of connected HPO terms

pub fn as_bytes(&self) -> Vec<u8>

Returns a binary representation of the Gene

The binary layout is defined as:

Byte offset	Number of bytes	Description
0	4	The total length of the binary data blob as big-endian u32
4	4	The Gene ID as big-endian u32
8	1	The length of the Gene Name / Symbol (converted to a u8 vector) as a u8
9	n	The Gene name/symbol as u8 vector. If the name has more than 255 bytes, it is trimmed to 255
9 + n	4	The number of associated HPO terms as big-endian u32
13 + n	x * 4	The HPO Term IDs of the associated terms, each encoded as big-endian u32

Examples

use hpo::annotations::Gene;

let mut gene = Gene::from_parts("123", "FooBar").unwrap();
let bytes = gene.as_bytes();

assert_eq!(bytes.len(), 4 + 4 + 1 + 6 + 4);
assert_eq!(bytes[4..8], [0u8, 0u8, 0u8, 123u8]);
assert_eq!(bytes[8], 6u8);

pub fn to_hpo_set<'a>(&self, ontology: &'a Ontology) -> HpoSet<'a>

Returns an HpoSet from the Gene

Trait Implementations

impl Clone for Gene

fn clone(&self) -> Gene

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Gene

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

Formats the value using the given formatter.

impl Default for Gene

fn default() -> Gene

Returns the “default value” for a type.

impl Hash for Gene

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Gene

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&[u8]> for Gene

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Returns a Gene from a bytes vector

The byte layout for this method is defined in Gene::as_bytes

Examples

use hpo::annotations::{Gene, GeneId};

let bytes = vec![
    0u8, 0u8, 0u8, 19u8, // Total size of Blop
    0u8, 0u8, 0u8, 123u8, // ID of the gene => 123
    6u8, // Length of gene symbol
    b'F', b'o', b'o', b'b', b'a', b'r', // Foobar
    0u8, 0u8, 0u8, 0u8  // Number of associated HPO Terms => 0
];
let gene = Gene::try_from(&bytes[..]).unwrap();

assert_eq!(gene.name(), "Foobar");
assert_eq!(gene.id(), &GeneId::from(123u32));

type Error = HpoError

The type returned in the event of a conversion error.

impl Eq for Gene