cloudburst 0.0.5

A library to help with the implementation of torrent based protocols and algorithms.
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

// Copyright 2022 Bryant Luk
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

#![doc = include_str!("../README.md")]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![warn(
    rust_2018_idioms,
    missing_docs,
    missing_debug_implementations,
    unused_lifetimes,
    unused_qualifications
)]
#![cfg_attr(not(feature = "std"), no_std)]

#[cfg(all(feature = "alloc", not(feature = "std")))]
extern crate alloc;

macro_rules! fmt_byte_array {
    ($id:ident) => {
        impl fmt::Debug for $id {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                struct DebugFmt<'a>(&'a $id);

                impl<'a> fmt::Debug for DebugFmt<'a> {
                    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                        for b in (self.0).0 {
                            write!(f, "{:02X}", b)?;
                        }
                        Ok(())
                    }
                }

                f.debug_tuple(stringify!($id))
                    .field(&DebugFmt(self))
                    .finish()
            }
        }

        impl fmt::Display for $id {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                for b in self.0 {
                    write!(f, "{:02X}", b)?;
                }
                Ok(())
            }
        }

        impl core::fmt::UpperHex for $id {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                if f.alternate() {
                    write!(f, "0x")?;
                }

                for b in self.0 {
                    write!(f, "{:02X}", b)?;
                }

                Ok(())
            }
        }

        impl fmt::LowerHex for $id {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                if f.alternate() {
                    write!(f, "0x")?;
                }

                for b in self.0 {
                    write!(f, "{:02x}", b)?;
                }

                Ok(())
            }
        }

        impl fmt::Binary for $id {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                if f.alternate() {
                    write!(f, "0b")?;
                }

                for b in self.0 {
                    write!(f, "{:b}", b)?;
                }

                Ok(())
            }
        }
    };
}

pub mod conn;
pub mod dht;
pub mod metainfo;
pub mod peer;
pub mod piece;
pub mod protocol;
pub mod time;
pub mod torrent;