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

#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
pub enum IPAddressVersion{
    IpV4,
    IpV6
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
pub enum ProtocolType{
    TCP,
    UDP,
    WEBSOCKET
}

#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd)]
pub struct AddressParser {
    pub ip_address:String,
    pub port_no:usize,
    pub protocol_type:ProtocolType,
    pub ip_version:IPAddressVersion
}

impl AddressParser {
    pub fn object_to_string(address_object:AddressParser)->String{
        let mut result_str=String::from("/ipv4/");
        if address_object.ip_version==IPAddressVersion::IpV6 {
            result_str.push_str("/ipv6/");
        }
        result_str.push_str(&address_object.ip_address);
        if address_object.protocol_type==ProtocolType::TCP {
            result_str.push_str("/tcp/");
        }else{
            result_str.push_str("/udp/");
        }
        result_str.push_str(&address_object.port_no.to_string());
        result_str
    }
    pub fn string_to_object(address_string:String)->AddressParser{
        let tmp_arr=address_string.split("/");
        let mut tmp_type=ProtocolType::TCP;
        let mut tmp_ip_ver=IPAddressVersion::IpV4;
        let mut tmp_ip_addr=String::from("0.0.0.0");
        let mut tmp_port_no=usize::MIN;
        let mut started=false;
        let mut count=0;
        for part in tmp_arr {
            if started==true{
                if count==0{
                    tmp_ip_addr=part.to_string();
                }
                if count==1{
                    if part.eq("tcp"){
                        tmp_type=ProtocolType::TCP;
                    }
                    if part.eq("udp"){
                        tmp_type=ProtocolType::UDP;
                    }
                }
                if count==2{
                    tmp_port_no=part.parse().unwrap_or_default();
                }
                count=count+1;
            }
            if part.eq("ipv4"){
                tmp_ip_ver=IPAddressVersion::IpV4;
                started=true;
            }
            if part.eq("ipv6"){
                tmp_ip_ver=IPAddressVersion::IpV6;
                started=true;
            }
        }        
        AddressParser{
            ip_address:tmp_ip_addr,
            port_no:tmp_port_no,
            protocol_type:tmp_type,
            ip_version:tmp_ip_ver,
        }
    }
    pub fn binding_addr_to_object(local_addr:String, protocol_type:ProtocolType, ip_version:IPAddressVersion)->AddressParser{
        let collection = local_addr.split(":").collect::<Vec<&str>>();
        AddressParser{
            ip_address: collection[0].to_string(),
            port_no: collection[1].parse::<usize>().unwrap(),
            protocol_type,
            ip_version,
        }
    }
    pub fn binding_addr_to_string(local_addr:String, protocol_type:ProtocolType, ip_version:IPAddressVersion)->String{
        AddressParser::object_to_string(
            AddressParser::binding_addr_to_object(
                local_addr, 
                protocol_type, 
                ip_version
            )
        )
    }
    pub fn local_addr_for_binding(address_object:AddressParser)->String{
        let mut bind_str = address_object.ip_address;
        bind_str.push_str(":");
        bind_str.push_str(&address_object.port_no.to_string());
        bind_str
    }
}

#[test]
fn full_test() {
    // cargo test  --lib full_test -- --nocapture
    
    let addr_obj=AddressParser{
        ip_version: IPAddressVersion::IpV4,
        ip_address:"127.0.0.1".to_string(),
        port_no:1234,
        protocol_type:ProtocolType::TCP
    };
    let addr_str=AddressParser::object_to_string(addr_obj.clone());
    
    //let local_addr_for_socket=AddressParser::local_addr_for_binding(addr_obj.clone());
    //println!("local_addr_for_socket: {}",local_addr_for_socket.clone());

    let convert_obj=AddressParser::string_to_object(addr_str.clone());

    if addr_obj.eq(&convert_obj.clone()){
        assert_eq!(true,true)
    }else{
        assert_eq!(false,true)
    }
}