Struct hpo::annotations::OmimDisease

pub struct OmimDisease { /* private fields */ }

A single OMIM disease

A disease has a unique OmimDiseaseId and a name and is connected to a set of HPO terms

Implementations

impl OmimDisease

pub fn new(id: OmimDiseaseId, name: &str) -> OmimDisease

Initializes a new OMIM disease

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

pub fn id(&self) -> &OmimDiseaseId

The unique OmimDiseaseId of the disease, the OMIM MIM number

pub fn name(&self) -> &str

The OMIM disease name

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

Connect another HPO term to the disease

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 OmimDisease

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 OmimDiseaseId as big-endian u32
8	4	The length of the OmimDisease Name as big-endian u32
12	n	The OmimDisease name as u8 vector
12 + n	4	The number of associated HPO terms as big-endian u32
16 + n	x * 4	The HpoTermIds of the associated terms, each encoded as big-endian u32

Examples

use hpo::annotations::OmimDisease;

let mut disease = OmimDisease::new(123.into(), "FooBar");
let bytes = disease.as_bytes();

assert_eq!(bytes.len(), 4 + 4 + 4 + 6 + 4);
assert_eq!(bytes[4..8], [0u8, 0u8, 0u8, 123u8]); // ID of disease => 123
assert_eq!(bytes[8..12], [0u8, 0u8, 0u8, 6u8]); // Length of Name => 6

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

Returns an HpoSet from the OmimDisease

Trait Implementations

impl Clone for OmimDisease

fn clone(&self) -> OmimDisease

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OmimDisease

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

Formats the value using the given formatter.

impl Default for OmimDisease

fn default() -> OmimDisease

Returns the “default value” for a type.

impl Hash for OmimDisease

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 OmimDisease

fn eq(&self, other: &OmimDisease) -> 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 OmimDisease

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

Returns an OmimDisease from a bytes vector

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

Examples

use hpo::annotations::{OmimDisease, OmimDiseaseId};

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

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

type Error = HpoError

The type returned in the event of a conversion error.

impl Eq for OmimDisease