rust_asio 0.5.3

Asynchronous I/O library
Documentation 
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

use std::mem;
use std::ops::{Deref, DerefMut};
use libc::sockaddr;
use super::SockAddrTrait;

#[derive(Clone)]
pub struct SockAddrImpl<T> {
    sa: T,
}

impl<T: SockAddrTrait> SockAddrImpl<T> {
    pub fn new(sa_family: i32, sa_len: usize) -> SockAddrImpl<T> {
        let mut sa: T = unsafe { mem::uninitialized() };
        {
            let sa = unsafe { &mut *(&mut sa as *mut _ as *mut sockaddr) };
            sa.sa_len = sa_len as u8;
            sa.sa_family = sa_family as u8;
        }
        SockAddrImpl {
            sa: sa,
        }
    }

    pub unsafe fn as_sockaddr<U>(&self) -> &U {
        &*(&self.sa as *const _ as *const U)
    }

    pub unsafe fn as_mut_sockaddr<U>(&mut self) -> &mut U {
        &mut *(&mut self.sa as *mut _ as *mut U)
    }

    pub fn capacity(&self) -> usize {
        mem::size_of::<T>()
    }

    pub fn size(&self) -> usize {
        let sa: &sockaddr = unsafe { self.as_sockaddr() };
        sa.sa_len as usize
    }

    pub unsafe fn resize(&mut self, size: usize) {
        let sa: &mut sockaddr = self.as_mut_sockaddr();
        sa.sa_len = size as u8;
    }
}

impl SockAddrImpl<Box<[u8]>> {
    pub fn from_vec(vec: Vec<u8>, sa_len: usize) -> SockAddrImpl<Box<[u8]>> {
        let mut sa = vec.into_boxed_slice();
        sa[0] = sa_len as u8;
        SockAddrImpl {
            sa: sa,
        }
    }

    pub unsafe fn as_sockaddr<U>(&self) -> &U {
        &*(self.sa.as_ptr() as *const U)
    }

    pub unsafe fn as_mut_sockaddr<U>(&mut self) -> &mut U {
        &mut *(self.sa.as_mut_ptr() as *mut U)
    }

    pub fn capacity(&self) -> usize {
        self.sa.len()
    }

    pub fn size(&self) -> usize {
        let sa: &sockaddr = unsafe { self.as_sockaddr() };
        sa.sa_len as usize
    }

    pub unsafe fn resize(&mut self, size: usize) {
        let sa: &mut sockaddr = self.as_mut_sockaddr();
        sa.sa_len = size as u8;
    }
}

impl<T: SockAddrTrait> Deref for SockAddrImpl<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.sa
    }
}

impl<T: SockAddrTrait> DerefMut for SockAddrImpl<T> {
    fn deref_mut(&mut self) -> &mut T {
        &mut self.sa
    }
}

impl Deref for SockAddrImpl<Box<[u8]>> {
    type Target = sockaddr;

    fn deref(&self) -> &sockaddr {
        unsafe { self.as_sockaddr() }
    }
}

impl DerefMut for SockAddrImpl<Box<[u8]>> {
    fn deref_mut(&mut self) -> &mut sockaddr {
        unsafe { self.as_mut_sockaddr() }
    }
}