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
113
114

//!

use crate::*;


impl<T> Deltoid for Option<T>
where T: Deltoid + PartialEq + Clone + std::fmt::Debug
    + for<'de> serde::Deserialize<'de>
    + serde::Serialize
    + IntoDelta
    + FromDelta
{
    type Delta = OptionDelta<T>;

    fn apply_delta(&self, delta: &Self::Delta) -> DeltaResult<Self> {
        if let Self::None = self {
            if let Self::Delta::None = delta {
                return Ok(Self::None);
            }
        }
        if let Self::Some(t) = self {
            if let Self::Delta::Some(delta_t) = delta {
                return Ok(Self::Some(
                    match delta_t.as_ref() {
                        None => t.clone(),
                        Some(d) => t.apply_delta(d)?,
                    },
                ));
            }
        }
        if let Self::Delta::None = delta {
            return Ok(Self::None);
        }
        if let Self::Delta::Some(delta_t) = delta {
            return Ok(Self::Some(
                match delta_t.as_ref() {
                    Some(d) => <T>::from_delta(d.clone())?,
                    None => return Err(DeltaError::ExpectedValue)?,
                },
            ));
        }
        crate::bug_detected!()
    }

    fn delta(&self, rhs: &Self) -> DeltaResult<Self::Delta> {
        if let Self::None = self {
            if let Self::None = rhs {
                return Ok(Self::Delta::None);
            }
        }
        if let Self::Some(lhs_0) = self {
            if let Self::Some(rhs_0) = rhs {
                let delta_0: Option<<T as Deltoid>::Delta> = if lhs_0 != rhs_0 {
                    Some(lhs_0.delta(&rhs_0)?)
                } else {
                    None
                };
                return Ok(Self::Delta::Some(delta_0));
            }
        }
        if let Self::None = rhs {
            return Ok(Self::Delta::None);
        }
        if let Self::Some(t) = rhs {
            return Ok(Self::Delta::Some(
                Some(t.clone().into_delta()?),
            ));
        }
        crate::bug_detected!()
    }
}


#[derive(Clone, Debug, PartialEq)]
#[derive(serde_derive::Deserialize, serde_derive::Serialize)]
pub enum OptionDelta<T: Deltoid> {
    None,
    Some(Option<<T as Deltoid>::Delta>),
}


impl<T> IntoDelta for Option<T>
where T: Deltoid + IntoDelta
    + for<'de> serde::Deserialize<'de>
    + serde::Serialize
    + IntoDelta
    + FromDelta
{
    fn into_delta(self) -> DeltaResult<<Self as Deltoid>::Delta> {
        Ok(match self {
            Self::None => OptionDelta::None,
            Self::Some(field0) => OptionDelta::Some(
                Some(field0.into_delta()?)
            ),
        })
    }
}

impl<T> FromDelta for Option<T>
where T: Deltoid + FromDelta
    + for<'de> serde::Deserialize<'de>
    + serde::Serialize
    + IntoDelta
    + FromDelta
{
    fn from_delta(delta: <Self as Deltoid>::Delta) -> DeltaResult<Self> {
        Ok(match delta {
            Self::Delta::None => Self::None,
            Self::Delta::Some(field0) => Self::Some(
                <T>::from_delta(field0.ok_or(DeltaError::ExpectedValue)?)?,
            ),
        })
    }
}