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
115
116
117
118
119
120
121
122
123
124
125
126
127

// Copyright 2019-2024 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0, MIT
use std::ops::{Deref, DerefMut};

use crate::lotus_json::lotus_json_with_self;

use super::fvm_shared_latest::version::NetworkVersion as NetworkVersion_latest;
pub use fvm_shared2::version::NetworkVersion as NetworkVersion_v2;
use fvm_shared3::version::NetworkVersion as NetworkVersion_v3;
use fvm_shared4::version::NetworkVersion as NetworkVersion_v4;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

/// Specifies the network version
///
/// # Examples
/// ```
/// # use forest_filecoin::doctest_private::NetworkVersion;
/// let v0 = NetworkVersion::V0;
///
/// // dereference to convert to FVM4
/// assert_eq!(fvm_shared4::version::NetworkVersion::V0, *v0);
///
/// // use `.into()` when FVM3 has to be specified.
/// assert_eq!(fvm_shared3::version::NetworkVersion::V0, v0.into());
///
/// // use `.into()` when FVM2 has to be specified.
/// assert_eq!(fvm_shared2::version::NetworkVersion::V0, v0.into());
/// ```
#[derive(
    Debug, Eq, PartialEq, Clone, Copy, Ord, PartialOrd, Serialize, Deserialize, JsonSchema,
)]
#[repr(transparent)]
#[serde(transparent)]
pub struct NetworkVersion(#[schemars(with = "u32")] pub NetworkVersion_latest);

lotus_json_with_self!(NetworkVersion);

impl NetworkVersion {
    pub const V0: Self = Self(NetworkVersion_latest::new(0));
    pub const V1: Self = Self(NetworkVersion_latest::new(1));
    pub const V2: Self = Self(NetworkVersion_latest::new(2));
    pub const V3: Self = Self(NetworkVersion_latest::new(3));
    pub const V4: Self = Self(NetworkVersion_latest::new(4));
    pub const V5: Self = Self(NetworkVersion_latest::new(5));
    pub const V6: Self = Self(NetworkVersion_latest::new(6));
    pub const V7: Self = Self(NetworkVersion_latest::new(7));
    pub const V8: Self = Self(NetworkVersion_latest::new(8));
    pub const V9: Self = Self(NetworkVersion_latest::new(9));
    pub const V10: Self = Self(NetworkVersion_latest::new(10));
    pub const V11: Self = Self(NetworkVersion_latest::new(11));
    pub const V12: Self = Self(NetworkVersion_latest::new(12));
    pub const V13: Self = Self(NetworkVersion_latest::new(13));
    pub const V14: Self = Self(NetworkVersion_latest::new(14));
    pub const V15: Self = Self(NetworkVersion_latest::new(15));
    pub const V16: Self = Self(NetworkVersion_latest::new(16));
    pub const V17: Self = Self(NetworkVersion_latest::new(17));
    pub const V18: Self = Self(NetworkVersion_latest::new(18));
    pub const V19: Self = Self(NetworkVersion_latest::new(19));
    pub const V20: Self = Self(NetworkVersion_latest::new(20));
    pub const V21: Self = Self(NetworkVersion_latest::new(21));
    pub const V22: Self = Self(NetworkVersion_latest::new(22));
    pub const V23: Self = Self(NetworkVersion_latest::new(23));
}

impl Deref for NetworkVersion {
    type Target = NetworkVersion_latest;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for NetworkVersion {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl From<u32> for NetworkVersion {
    fn from(value: u32) -> Self {
        NetworkVersion(NetworkVersion_latest::new(value))
    }
}

impl From<NetworkVersion_v2> for NetworkVersion {
    fn from(value: NetworkVersion_v2) -> Self {
        NetworkVersion((value as u32).into())
    }
}

impl From<NetworkVersion_v3> for NetworkVersion {
    fn from(value: NetworkVersion_v3) -> Self {
        NetworkVersion(u32::from(value).into())
    }
}

impl From<NetworkVersion_v4> for NetworkVersion {
    fn from(value: NetworkVersion_v4) -> Self {
        NetworkVersion(value)
    }
}

impl From<NetworkVersion> for NetworkVersion_v2 {
    fn from(other: NetworkVersion) -> NetworkVersion_v2 {
        u32::from(other.0).try_into().expect("Infallible")
    }
}

impl From<NetworkVersion> for NetworkVersion_v3 {
    fn from(other: NetworkVersion) -> Self {
        u32::from(other.0).into()
    }
}

impl From<NetworkVersion> for NetworkVersion_v4 {
    fn from(other: NetworkVersion) -> Self {
        other.0
    }
}

#[cfg(test)]
impl quickcheck::Arbitrary for NetworkVersion {
    fn arbitrary(g: &mut quickcheck::Gen) -> Self {
        let value = u32::arbitrary(g);
        NetworkVersion(NetworkVersion_latest::new(value))
    }
}