poasta 0.1.0

Fast, optimal, gap-affine partial order alignment
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use std::error::Error;
use std::fmt::{Debug, Display, Formatter};
use std::io;
use std::sync::mpsc::SendError;
use petgraph::algo::Cycle;

use crate::debug::messages::DebugOutputMessage;

#[derive(Debug)]
pub enum PoastaError {
    /// The size of the weights vector is not equal to the length of the sequence
    WeightsUnequalSize(usize, usize),

    /// The alignment did not include any valid positions
    InvalidAlignment,

    /// Error variant when something went wrong in the alignment
    AlignmentError,

    /// Error indicating the graph is in an invalid state
    GraphError,

    /// Error variant when we couldn't read from a file
    FileReadError { source: io::Error },

    /// Error variant when we could not serialize the graph to binary representation
    SerializationError { source: bincode::Error },

    /// Other IO errors
    IOError(io::Error),

    /// Other formatting errors
    FormatError(std::fmt::Error),

    /// Debug output error
    DebugError { source: SendError<DebugOutputMessage> },

    /// Other miscellaneous poasta errors
    Other,
}

impl Error for PoastaError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match *self {
            Self::FileReadError { ref source } => Some(source),
            Self::SerializationError { ref source } => Some(source),
            Self::IOError(ref source) => Some(source),
            Self::DebugError { ref source} => Some(source),
            _ => None
        }
    }
}


impl<N> From<Cycle<N>> for PoastaError {
    fn from(_: Cycle<N>) -> Self {
        Self::GraphError
    }
}

impl From<io::Error> for PoastaError {
    fn from(value: io::Error) -> Self {
        Self::IOError(value)
    }
}

impl From<bincode::Error> for PoastaError {
    fn from(value: bincode::Error) -> Self {
        Self::SerializationError {
            source: value
        }
    }
}

impl From<SendError<DebugOutputMessage>> for PoastaError {
    fn from(value: SendError<DebugOutputMessage>) -> Self {
        Self::DebugError { source: value }
    }
}

impl From<std::fmt::Error> for PoastaError {
    fn from(value: std::fmt::Error) -> Self {
        Self::FormatError(value)
    }
}

impl Display for PoastaError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match *self {
            Self::WeightsUnequalSize(seq_len, weights_len) =>
                write!(f, "The length of the weights vector ({weights_len}) does not match the length of the sequence ({seq_len})!"),
            Self::InvalidAlignment =>
                write!(f, "The specified alignment did not include any valid sequence positions!"),
            Self::GraphError =>
                write!(f, "The graph is in an invalid state (possibly a cycle?)."),
            Self::AlignmentError =>
                write!(f, "Something went wrong with the alignment!"),
            Self::FileReadError { source: _ } =>
                write!(f, "Could not read from file!"),
            Self::SerializationError { source: _ } =>
                write!(f, "Error loading/saving the graph from a POASTA graph file!"),
            Self::IOError(ref err) =>
                std::fmt::Display::fmt(err, f),
            Self::FormatError(ref err) =>
                std::fmt::Display::fmt(err, f),
            Self::DebugError { source: _ } =>
                write!(f, "Could not log debug data!"),
            Self::Other =>
                write!(f, "Poasta error!")
        }
    }
}