Skip to content

Commit 313218e

Browse files
mabelsmabels
committed
chore: update dart
1 parent 62a1f3f commit 313218e

22 files changed

+1081
-1176
lines changed

‎dart/ipaddress/IPAddress.dart‎

Lines changed: 106 additions & 107 deletions
Large diffs are not rendered by default.

‎dart/ipaddress/IpV4.dart‎

Lines changed: 32 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1,69 +1,70 @@
1+
import 'package:result_monad/result_monad.dart';
2+
13
import 'IPAddress.dart';
24
import 'IpBits.dart';
35
import 'IpV6.dart';
46
import 'Prefix128.dart';
57
import 'Prefix32.dart';
6-
import 'Result.dart';
78

89
class IpV4 {
910
static bool ipv4_is_private(IPAddress my) {
1011
return [
11-
IPAddress.parse("10.0.0.0/8").unwrap(),
12-
IPAddress.parse("169.254.0.0/16").unwrap(),
13-
IPAddress.parse("172.16.0.0/12").unwrap(),
14-
IPAddress.parse("192.168.0.0/16").unwrap()
12+
IPAddress.parse("10.0.0.0/8").value,
13+
IPAddress.parse("169.254.0.0/16").value,
14+
IPAddress.parse("172.16.0.0/12").value,
15+
IPAddress.parse("192.168.0.0/16").value
1516
].indexWhere((i) => i.includes(my)) >=
1617
0;
1718
}
1819

1920
static bool ipv4_is_loopback(IPAddress my) {
20-
return IPAddress.parse("127.0.0.0/8").unwrap().includes(my);
21+
return IPAddress.parse("127.0.0.0/8").value.includes(my);
2122
}
2223

2324
static IPAddress to_ipv6(IPAddress ia) {
2425
return IPAddress(
2526
IpBits.V6,
2627
ia.host_address,
27-
Prefix128.create(ia.prefix.num).unwrap(),
28+
Prefix128.create(ia.prefix.num).value,
2829
null,
2930
IpV6.ipv6_is_private,
3031
IpV6.ipv6_is_loopback,
3132
IpV6.ipv6_to_ipv6);
3233
}
3334

34-
static Result<IPAddress> from_u32(int addr, int _prefix) {
35+
static Result<IPAddress, String> from_u32(int addr, int _prefix) {
3536
final prefix = Prefix32.create(_prefix);
36-
if (prefix.isErr()) {
37-
return Result.Err(prefix.unwrapErr());
37+
if (prefix.isFailure) {
38+
return Result.error(prefix.error);
3839
}
39-
return Result.Ok(IPAddress(IpBits.v4(), BigInt.from(addr), prefix.unwrap(),
40+
return Result.ok(IPAddress(IpBits.v4(), BigInt.from(addr), prefix.value,
4041
null, ipv4_is_private, ipv4_is_loopback, to_ipv6));
4142
}
4243

43-
static Result<IPAddress> create(String str) {
44+
static Result<IPAddress, String> create(String str) {
4445
final splitted = IPAddress.split_at_slash(str);
4546
if (!IPAddress.is_valid_ipv4(splitted.addr)) {
46-
return Result.Err("IpV4-create: Invalid IP ${str}");
47+
return Result.error("IpV4-create: Invalid IP ${str}");
4748
}
48-
var ip_prefix_num = Result.Ok(32);
49+
var ip_prefix_num = Result.ok(32);
4950
if (splitted.netmask != null) {
5051
// netmask is defined
51-
ip_prefix_num = IPAddress.parse_netmask_to_prefix(splitted.netmask);
52-
if (ip_prefix_num.isErr()) {
53-
return Result.Err(ip_prefix_num.unwrapErr());
52+
ip_prefix_num = IPAddress.parse_netmask_to_prefix(splitted.netmask!);
53+
if (ip_prefix_num.isFailure) {
54+
return Result.error(ip_prefix_num.error);
5455
}
5556
//if ip_prefix.ip_bits.version
5657
}
57-
final ip_prefix = Prefix32.create(ip_prefix_num.unwrap());
58-
if (ip_prefix.isErr()) {
59-
return Result.Err(ip_prefix.unwrapErr());
58+
final ip_prefix = Prefix32.create(ip_prefix_num.value);
59+
if (ip_prefix.isFailure) {
60+
return Result.error(ip_prefix.error);
6061
}
6162
final split_u32 = IPAddress.split_to_u32(splitted.addr);
62-
if (split_u32.isErr()) {
63-
return Result.Err(split_u32.unwrapErr());
63+
if (split_u32.isFailure) {
64+
return Result.error(split_u32.error);
6465
}
65-
return Result.Ok(IPAddress(IpBits.V4, BigInt.from(split_u32.unwrap()),
66-
ip_prefix.unwrap(), null, ipv4_is_private, ipv4_is_loopback, to_ipv6));
66+
return Result.ok(IPAddress(IpBits.V4, BigInt.from(split_u32.value),
67+
ip_prefix.value, null, ipv4_is_private, ipv4_is_loopback, to_ipv6));
6768
}
6869

6970
// pub fn is_private(my: &IPAddress) -> bool {
@@ -1097,9 +1098,9 @@ class IpV4 {
10971098

10981099
// return String.format("{:04x}:{:04x}",
10991100

1100-
// (my.host_address >> 16).mod_floor(&part_mod).to_u16().unwrap(),
1101+
// (my.host_address >> 16).mod_floor(&part_mod).to_u16().value,
11011102

1102-
// my.host_address.mod_floor(&part_mod).to_u16().unwrap());
1103+
// my.host_address.mod_floor(&part_mod).to_u16().value);
11031104
// }
11041105

11051106
// Creates a IPv4 object from an
@@ -1310,22 +1311,22 @@ class IpV4 {
13101311
// prefix of /24 or 255.255.255.0
13111312

13121313
//
1313-
static Result<IPAddress> parse_classful(String ip_s) {
1314+
static Result<IPAddress, String> parse_classful(String ip_s) {
13141315
if (!IPAddress.is_valid_ipv4(ip_s)) {
1315-
return Result.Err("parse_classful: Invalid IP ${ip_s}");
1316+
return Result.error("parse_classful: Invalid IP ${ip_s}");
13161317
}
13171318
final o_ip = IPAddress.parse(ip_s);
1318-
if (o_ip.isErr()) {
1319+
if (o_ip.isFailure) {
13191320
return o_ip;
13201321
}
1321-
final ip = o_ip.unwrap();
1322+
final ip = o_ip.value;
13221323
if (IpV4.is_class_a(ip)) {
13231324
return IPAddress.parse("${ip.to_s()}/8");
13241325
} else if (IpV4.is_class_b(ip)) {
13251326
return IPAddress.parse("${ip.to_s()}/16");
13261327
} else if (IpV4.is_class_c(ip)) {
13271328
return IPAddress.parse("${ip.to_s()}/24");
13281329
}
1329-
return Result.Ok(ip);
1330+
return Result.ok(ip);
13301331
}
13311332
}

‎dart/ipaddress/IpV6.dart‎

Lines changed: 27 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,9 @@
1+
import 'package:result_monad/result_monad.dart';
2+
13
import 'IPAddress.dart';
24
import 'IpBits.dart';
35
import 'IpV4.dart';
46
import 'Prefix128.dart';
5-
import 'Result.dart';
67

78
class IpV6 {
89
/// =Name
@@ -110,54 +111,54 @@ class IpV6 {
110111
static final VtBool ipv6_is_loopback =
111112
(IPAddress my) => my.host_address == BigInt.one;
112113
static final VtBool ipv6_is_private =
113-
(IPAddress my) => IPAddress.parse("fd00::/8").unwrap().includes(my);
114+
(IPAddress my) => IPAddress.parse("fd00::/8").value.includes(my);
114115

115-
static Result<IPAddress> from_str(String str, int radix, int prefix) {
116+
static Result<IPAddress, String> from_str(String str, int radix, int prefix) {
116117
try {
117118
final num = BigInt.parse(str, radix: radix);
118119
return from_int(num, prefix);
119120
} catch (e) {
120-
return Result.Err("unparsable ${str}");
121+
return Result.error("unparsable ${str}");
121122
}
122123
}
123124

124-
static Result<IPAddress> enhance_if_mapped(IPAddress ip) {
125+
static Result<IPAddress, String> enhance_if_mapped(IPAddress ip) {
125126
// println!("real mapped {:x} {:x}", &ip.host_address, ip.host_address.clone().shr(32));
126127
if (ip.is_mapped()) {
127-
return Result.Ok(ip);
128+
return Result.ok(ip);
128129
}
129130
final ipv6_top_96bit = ip.host_address >> 32;
130131
if (ipv6_top_96bit == BigInt.from(0xffff)) {
131132
// println!("enhance_if_mapped-1:{}", );
132133
final num = ip.host_address % (BigInt.one << 32);
133134
if (num == BigInt.zero) {
134-
return Result.Ok(ip);
135+
return Result.ok(ip);
135136
}
136137
//println!("ip:{},{:x}", ip.to_string(), num);
137138
final ipv4_bits = IpBits.V4;
138139
if (ipv4_bits.bits < ip.prefix.host_prefix()) {
139140
//println!("enhance_if_mapped-2:{}:{}", ip.to_string(), ip.prefix.host_prefix());
140-
return Result.Err(
141+
return Result.error(
141142
"enhance_if_mapped prefix not ipv4 compatible ${ip.prefix.host_prefix()}");
142143
}
143144
final mapped =
144145
IpV4.from_u32(num.toInt(), ipv4_bits.bits - ip.prefix.host_prefix());
145-
if (mapped.isErr()) {
146+
if (mapped.isFailure) {
146147
//println!("enhance_if_mapped-3");
147148
return mapped;
148149
}
149-
// println!("real mapped!!!!!={}", mapped.clone().unwrap().to_string());
150-
return Result.Ok(ip.setMappedIpaddress(mapped.unwrap()));
150+
// println!("real mapped!!!!!={}", mapped.clone().value.to_string());
151+
return Result.ok(ip.setMappedIpaddress(mapped.value));
151152
}
152-
return Result.Ok(ip);
153+
return Result.ok(ip);
153154
}
154155

155-
static Result<IPAddress> from_int(BigInt bi, int prefixNum) {
156+
static Result<IPAddress, String> from_int(BigInt bi, int prefixNum) {
156157
final prefix = Prefix128.create(prefixNum);
157-
if (prefix.isErr()) {
158-
return Result.Err(prefix.unwrapErr());
158+
if (prefix.isFailure) {
159+
return Result.error(prefix.error);
159160
}
160-
return enhance_if_mapped(IPAddress(IpBits.V6, bi, prefix.unwrap(), null,
161+
return enhance_if_mapped(IPAddress(IpBits.V6, bi, prefix.value, null,
161162
ipv6_is_private, ipv6_is_loopback, ipv6_to_ipv6));
162163
}
163164

@@ -186,36 +187,30 @@ class IpV6 {
186187
187188
/// ip6 = IPAddress "2001:db8::8:800:200c:417a/64"
188189
///
189-
static Result<IPAddress> create(String str) {
190+
static Result<IPAddress, String> create(String str) {
190191
final splitted = IPAddress.split_at_slash(str);
191192
if (IPAddress.is_valid_ipv6(splitted.addr)) {
192193
final o_num = IPAddress.split_to_num(splitted.addr);
193-
if (o_num.isErr()) {
194-
return Result.Err(o_num.unwrapErr());
194+
if (o_num.isFailure) {
195+
return Result.error(o_num.error);
195196
}
196197
var netmask = 128;
197198
if (splitted.netmask != null) {
198199
final network = splitted.netmask;
199-
final num_mask = IPAddress.parseInt(network, 10);
200+
final num_mask = IPAddress.parseInt(network!, 10);
200201
if (num_mask == null) {
201-
return Result.Err("Invalid Netmask ${str}");
202+
return Result.error("Invalid Netmask ${str}");
202203
}
203204
netmask = num_mask.toInt();
204205
}
205206
final prefix = Prefix128.create(netmask);
206-
if (prefix.isErr()) {
207-
return Result.Err(prefix.unwrapErr());
207+
if (prefix.isFailure) {
208+
return Result.error(prefix.error);
208209
}
209-
return enhance_if_mapped(IPAddress(
210-
IpBits.V6,
211-
o_num.unwrap(),
212-
prefix.unwrap(),
213-
null,
214-
ipv6_is_private,
215-
ipv6_is_loopback,
216-
ipv6_to_ipv6));
210+
return enhance_if_mapped(IPAddress(IpBits.V6, o_num.value, prefix.value,
211+
null, ipv6_is_private, ipv6_is_loopback, ipv6_to_ipv6));
217212
} else {
218-
return Result.Err("Invalid IP ${str}");
213+
return Result.error("Invalid IP ${str}");
219214
}
220215
}
221216
}

‎dart/ipaddress/Ipv6Loopback.dart‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,6 @@ import 'IpV6.dart';
4646
///
4747
class Ipv6Loopback {
4848
static IPAddress create() {
49-
return IpV6.from_int(BigInt.one, 128).unwrap();
49+
return IpV6.from_int(BigInt.one, 128).value;
5050
}
5151
}

‎dart/ipaddress/Ipv6Mapped.dart‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,10 @@
11
// Ac
22
import 'dart:core';
33

4+
import 'package:result_monad/result_monad.dart';
5+
46
import 'IPAddress.dart';
57
import 'IpBits.dart';
6-
import 'Result.dart';
78

89
/// It is usually identified as a IPv4 mapped IPv6 address, a particular
910
/// IPv6 address which aids the transition from IPv4 to IPv6. The
@@ -81,12 +82,12 @@ import 'Result.dart';
8182
/// /// "::ffff:13.1.68.3"
8283
///
8384
class Ipv6Mapped {
84-
static Result<IPAddress> create(String str) {
85+
static Result<IPAddress, String> create(String str) {
8586
final ret = IPAddress.split_at_slash(str);
8687
final split_colon = ret.addr.split(":");
8788
if (split_colon.length <= 1) {
8889
// println!("---1");
89-
return Result.Err("not mapped format-1: ${str}");
90+
return Result.error("not mapped format-1: ${str}");
9091
}
9192
var netmask = "";
9293
if (ret.netmask != null) {
@@ -95,12 +96,12 @@ class Ipv6Mapped {
9596
final ipv4_str = split_colon[split_colon.length - 1];
9697
if (IPAddress.is_valid_ipv4(ipv4_str)) {
9798
final ipv4 = IPAddress.parse("${ipv4_str}${netmask}");
98-
if (ipv4.isErr()) {
99+
if (ipv4.isFailure) {
99100
// println!("---2");
100101
return ipv4;
101102
}
102-
//mapped = Some(ipv4.unwrap());
103-
final addr = ipv4.unwrap();
103+
//mapped = Some(ipv4.value);
104+
final addr = ipv4.value;
104105
final ipv6_bits = IpBits.V6;
105106
final part_mod = ipv6_bits.part_mod;
106107
var up_addr = addr.host_address;
@@ -118,28 +119,28 @@ class Ipv6Mapped {
118119
${(up_addr >> (IpBits.V6.part_bits % part_mod.toInt())).toRadixString(16)}:${(down_addr % part_mod).toRadixString(16)}/${ipv6_bits.bits - addr.prefix.host_prefix()}""";
119120
rebuild_ipv6 += rebuild_ipv4;
120121
final r_ipv6 = IPAddress.parse(rebuild_ipv6.toString());
121-
if (r_ipv6.isErr()) {
122+
if (r_ipv6.isFailure) {
122123
// println!("---3|{}", &rebuild_ipv6);
123124
return r_ipv6;
124125
}
125-
if (r_ipv6.unwrap().is_mapped()) {
126+
if (r_ipv6.value.is_mapped()) {
126127
return r_ipv6;
127128
}
128-
final ipv6 = r_ipv6.unwrap();
129+
final ipv6 = r_ipv6.value;
129130
final p96bit = ipv6.host_address >> 32;
130131
if (p96bit != BigInt.zero) {
131132
// println!("---4|{}", &rebuild_ipv6);
132-
return Result.Err("is not a mapped address:${rebuild_ipv6}");
133+
return Result.error("is not a mapped address:${rebuild_ipv6}");
133134
}
134135
{
135136
final rr_ipv6 = IPAddress.parse("::ffff:${rebuild_ipv4}");
136-
if (rr_ipv6.isErr()) {
137+
if (rr_ipv6.isFailure) {
137138
//println!("---3|{}", &rebuild_ipv6);
138139
return rr_ipv6;
139140
}
140141
return rr_ipv6;
141142
}
142143
}
143-
return Result.Err("unknown mapped format:${str}");
144+
return Result.error("unknown mapped format:${str}");
144145
}
145146
}

‎dart/ipaddress/Ipv6Unspec.dart‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,6 @@ import 'IPAddress.dart';
5151
///
5252
class Ipv6Unspec {
5353
static IPAddress create() {
54-
return IPAddress.parse("::").unwrap();
54+
return IPAddress.parse("::").value;
5555
}
5656
}

0 commit comments

Comments
 (0)