std/net: adopt new time::Duration

std/jule/sema/builtin.jule

@@ -72,7 +72,7 @@ fn primTypeAlias(ident: str, mut &k: &Type, strict: bool): &TypeAlias {
 		Ident: ident,
 		TypeSym: &TypeSym{
 			Type: &Type{Kind: s},
-		}
+		},
 	}
 }
 

std/net/net.jule

@@ -21,8 +21,8 @@ trait Conn {
 	io::Reader
 	io::Writer
 	io::Closer
-	fn SetReadTimeout(mut self, timeout: time::DurInt)!
-	fn SetWriteTimeout(mut self, timeout: time::DurInt)!
+	fn SetReadTimeout(mut self, timeout: time::Duration)!
+	fn SetWriteTimeout(mut self, timeout: time::Duration)!
 	fn Network(self): Network
 }
 

std/net/sock.jule

@@ -78,7 +78,7 @@ fn Connect(network: Network, addr: str)!: Conn {
 // Timeout precision is microseconds.
 // If the timeout is below one microsecond it will be ignored.
 // If timeout is invalid or out of range, throws exceptional with Error.InvalidTimeout.
-fn ConnectTimeout(network: Network, addr: str, timeout: time::DurInt)!: Conn {
+fn ConnectTimeout(network: Network, addr: str, timeout: time::Duration)!: Conn {
 	match network {
 	| Network.Tcp | Network.Tcp4 | Network.Tcp6:
 		ret tcpConnect(network, addr, timeout) else { error(error) }
@@ -101,9 +101,9 @@ unsafe fn connectSocketNoTimeout(handle: netHandle, sockAddr: *sys::Sockaddr, so
 	}
 }
 
-fn timevalFromDuration(timeout: time::DurInt): (tv: sys::Timeval, ok: bool) {
-	sec := i64(time::Duration.Seconds(timeout))
-	usec := i64(time::Duration.Microseconds(timeout - (time::Duration.Second * time::DurInt(sec))))
+fn timevalFromDuration(timeout: time::Duration): (tv: sys::Timeval, ok: bool) {
+	sec := i64(timeout.Seconds())
+	usec := i64((timeout - time::Duration(i64(time::Second)*sec)).Microseconds())
 	ok = sys::NewTimeval(sec, usec, tv)
 	ret
 }

std/net/sock_unix.jule

@@ -41,7 +41,7 @@ fn openSocketBlockingMode(handle: netHandle)! {
 	}
 }
 
-unsafe fn connectSocket(handle: netHandle, sockAddr: *sys::Sockaddr, sockLen: uint, timeout: time::DurInt)! {
+unsafe fn connectSocket(handle: netHandle, sockAddr: *sys::Sockaddr, sockLen: uint, timeout: time::Duration)! {
 	if timeout == 0 {
 		connectSocketNoTimeout(handle, sockAddr, sockLen) else { error(error) }
 		ret
@@ -128,7 +128,7 @@ fn sendto(&conn: UdpConn, &buf: []byte)!: int {
 	error(lastErrorCode())
 }
 
-fn setSocketTimeout(handle: netHandle, scope: int, timeout: time::DurInt)! {
+fn setSocketTimeout(handle: netHandle, scope: int, timeout: time::Duration)! {
 	tv, ok := timevalFromDuration(timeout)
 	if !ok {
 		error(Error.InvalidTimeout)

std/net/sock_windows.jule

@@ -36,7 +36,7 @@ fn openSocketBlockingMode(handle: netHandle)! {
 	setSocketBlockingMode(handle, 0) else { error(error) }
 }
 
-unsafe fn connectSocket(handle: netHandle, sockAddr: *sys::Sockaddr, sockLen: uint, timeout: time::DurInt)! {
+unsafe fn connectSocket(handle: netHandle, sockAddr: *sys::Sockaddr, sockLen: uint, timeout: time::Duration)! {
 	if timeout == 0 {
 		connectSocketNoTimeout(handle, sockAddr, sockLen) else { error(error) }
 		ret
@@ -116,7 +116,7 @@ fn sendto(&conn: UdpConn, &buf: []byte)!: int {
 	error(lastErrorCode())
 }
 
-fn setSocketTimeout(handle: netHandle, scope: int, timeout: time::DurInt)! {
+fn setSocketTimeout(handle: netHandle, scope: int, timeout: time::Duration)! {
 	tv, ok := timevalFromDuration(timeout)
 	if !ok {
 		error(Error.InvalidTimeout)

std/net/tcp_conn.jule

@@ -72,7 +72,7 @@ impl TcpConn {
 	// If the timeout is below one microsecond it will be accepted as zero.
 	// The zero timeout, clears current timeout if exist.
 	// All exceptionals are error code of implementation.
-	fn SetReadTimeout(mut self, timeout: time::DurInt)! {
+	fn SetReadTimeout(mut self, timeout: time::Duration)! {
 		if self.handle == sys::INVALID_SOCKET {
 			panic("net: TcpConn.SetReadTimeout: connection is closed")
 		}
@@ -84,7 +84,7 @@ impl TcpConn {
 	// If the timeout is below one microsecond it will be accepted as zero.
 	// The zero timeout, clears current timeout if exist.
 	// All exceptionals are error code of implementation.
-	fn SetWriteTimeout(mut self, timeout: time::DurInt)! {
+	fn SetWriteTimeout(mut self, timeout: time::Duration)! {
 		if self.handle == sys::INVALID_SOCKET {
 			panic("net: TcpConn.SetReadTimeout: connection is closed")
 		}

std/net/tcp_listener.jule

@@ -38,7 +38,7 @@ impl TcpListener {
 	}
 
 	// Same as TcpListener.Connect, but uses timeout.
-	static fn ConnectTimeout(addr: str, timeout: time::DurInt)!: &TcpConn {
+	static fn ConnectTimeout(addr: str, timeout: time::Duration)!: &TcpConn {
 		ret tcpConnect(Network.Tcp, addr, timeout) else { error(error) }
 	}
 
@@ -219,7 +219,7 @@ fn tcpBind(network: Network, &addr: str)!: &TcpListener {
 	}
 }
 
-fn tcpConnect(network: Network, &addr: str, timeout: time::DurInt)!: &TcpConn {
+fn tcpConnect(network: Network, &addr: str, timeout: time::Duration)!: &TcpConn {
 	mut tcpAddr := TcpAddr.Resolve(network, addr) else { error(error) }
 	mut handle := netHandle(sys::INVALID_SOCKET)
 	mut v6 := false

std/net/udp_conn.jule

@@ -78,7 +78,7 @@ impl UdpConn {
 	// If the timeout is below one microsecond it will be accepted as zero.
 	// The zero timeout, clears current timeout if exist.
 	// All exceptionals are error code of implementation.
-	fn SetReadTimeout(mut self, timeout: time::DurInt)! {
+	fn SetReadTimeout(mut self, timeout: time::Duration)! {
 		if self.handle == sys::INVALID_SOCKET {
 			panic("net: TcpConn.SetReadTimeout: connection is closed")
 		}
@@ -90,7 +90,7 @@ impl UdpConn {
 	// If the timeout is below one microsecond it will be accepted as zero.
 	// The zero timeout, clears current timeout if exist.
 	// All exceptionals are error code of implementation.
-	fn SetWriteTimeout(mut self, timeout: time::DurInt)! {
+	fn SetWriteTimeout(mut self, timeout: time::Duration)! {
 		if self.handle == sys::INVALID_SOCKET {
 			panic("net: TcpConn.SetReadTimeout: connection is closed")
 		}

std/runtime/strconv.jule

@@ -77,7 +77,7 @@ fn u64ToBuf(mut buf: []byte, mut x: u64): int {
 
 	// reverse
 	i = 0
-	mut j := n-1
+	mut j := n - 1
 	for i < j; i, j = i+1, j-1 {
 		buf[i], buf[j] = buf[j], buf[i]
 	}