Struct BlobRef 

pub struct BlobRef {
    pub id: BlobId,
    pub size: u32,
    pub key: BlobKey,
}

Fields

id: BlobId

size: u32

key: BlobKey

Implementations

impl BlobRef

pub fn from_slice(data: &[u8]) -> Self

Examples found in repository

examples/chatwith.rs (line 29)

async fn handle_message(envelope: &Envelope, content: &[u8]) -> bool{
    let msg_type = content[0];
    let msg = &content[1..];
    use threema_client::msg_types::*;
    match (msg_type, msg.len()) {
        (TEXT, _) => {
            println!("{:?} ({}) => {:?}: {}", envelope.sender, envelope.nickname, &envelope.recipient, String::from_utf8_lossy(msg));
            true
        }
        (TYPING_INDICATOR, 1) => {
            let x = if msg[0] == 1 {"is"} else {"has stopped"};
            println!("{} ({:?}) {} typing", envelope.nickname, envelope.sender, x);
            false
        }
        (CONTACT_SET_PHOTO, 52) => {
            let blobref = threema_client::blob_api::BlobRef::from_slice(msg);
            println!("CONTACT_SET_PHOTO, blob {:?}, {}", blobref, blobref.hex());
            //let res = blob_api::Client::new().download(&blobref).await;
            //println!(":) {:?}", res);
            false
        }
        (unknown_type, unknown_length) => {
            eprintln!("Message with unknown type {} or length {}: {:?}", unknown_type, unknown_length, msg);
            false
        }
    }
}

examples/connect.rs (line 65)

    async fn handle_message(&mut self, envelope: &transport::Envelope, content: Vec<u8>) {
        let msg_type = content[0];
        let msg = &content[1..];
        use msg_types::*;
        match (msg_type, msg.len()) {
            (TEXT, _) => {
                println!("{:?} ({}) => {:?}: {}", envelope.sender, envelope.nickname, &envelope.recipient, String::from_utf8_lossy(msg));
                let _res = self.w.send_download_ack(envelope).await;
            }
            (TYPING_INDICATOR, 1) => {
                let x = if msg[0] == 1 {"is"} else {"has stopped"};
                println!("{} ({:?}) {} typing", envelope.nickname, envelope.sender, x);
            }
            (CONTACT_SET_PHOTO, 52) => {
                let blobref = blob_api::BlobRef::from_slice(msg);
                println!("CONTACT_SET_PHOTO, blob {:?}, {}", blobref, blobref.hex());
                //let res = blob_api::Client::new().download(&blobref).await;
                //println!(":) {:?}", res);
                
            }
            (unknown_type, unknown_length) => {
                eprintln!("Message with unknown type {} or length {}: {:?}", unknown_type, unknown_length, msg)
            }
        }
    }

pub fn from_hex(data: &str) -> Result<Self, ParseError>

Examples found in repository

examples/getblob.rs (line 24)

async fn main(){
    env_logger::init();
    let argv = std::env::args().collect::<Vec<_>>();
    let hexid;
    let mark_done;
    if argv.len() == 2 {
        hexid = &argv[1];
        mark_done = false;
    }
    else if argv.len() == 3 && argv[1] == "-d" {
        hexid = &argv[2];
        mark_done = true;
    }
    else {
        eprintln!("usage: {} HEXBLOBREF", std::env::args().next().unwrap());
        std::process::exit(1);
    }
    let blobref = blob_api::BlobRef::from_hex(hexid).expect("invalid id given.");
    let c = blob_api::Client::new();
    let blob = c.download(&blobref).await.expect("retrieving blob");
    std::io::stdout().lock().write_all(&blob).expect("write out failed");
    if mark_done {
        c.mark_done(&blobref.id).await.expect("mark_done failed");
    }
}

pub fn to_slice(&self, out: &mut [u8])

pub fn hex(&self) -> String

Examples found in repository

examples/putblob.rs (line 22)

async fn main(){
    env_logger::init();
    let argv = std::env::args().collect::<Vec<_>>();
    let mut blob = vec![];
    if argv.len() == 2 {
        let fname = &argv[1];
        let f = std::fs::File::open(fname).expect(fname);
        BufReader::new(f).read_to_end(&mut blob).expect(fname);
    }
    else {
        std::io::stdin().lock().read_to_end(&mut blob).expect("reading stdin");
    }
    let c = blob_api::Client::new();
    let blobid = c.upload(&blob).await.expect("upload blob");
    println!("{}", blobid.hex());
}

examples/chatwith.rs (line 30)

async fn handle_message(envelope: &Envelope, content: &[u8]) -> bool{
    let msg_type = content[0];
    let msg = &content[1..];
    use threema_client::msg_types::*;
    match (msg_type, msg.len()) {
        (TEXT, _) => {
            println!("{:?} ({}) => {:?}: {}", envelope.sender, envelope.nickname, &envelope.recipient, String::from_utf8_lossy(msg));
            true
        }
        (TYPING_INDICATOR, 1) => {
            let x = if msg[0] == 1 {"is"} else {"has stopped"};
            println!("{} ({:?}) {} typing", envelope.nickname, envelope.sender, x);
            false
        }
        (CONTACT_SET_PHOTO, 52) => {
            let blobref = threema_client::blob_api::BlobRef::from_slice(msg);
            println!("CONTACT_SET_PHOTO, blob {:?}, {}", blobref, blobref.hex());
            //let res = blob_api::Client::new().download(&blobref).await;
            //println!(":) {:?}", res);
            false
        }
        (unknown_type, unknown_length) => {
            eprintln!("Message with unknown type {} or length {}: {:?}", unknown_type, unknown_length, msg);
            false
        }
    }
}

examples/connect.rs (line 66)

    async fn handle_message(&mut self, envelope: &transport::Envelope, content: Vec<u8>) {
        let msg_type = content[0];
        let msg = &content[1..];
        use msg_types::*;
        match (msg_type, msg.len()) {
            (TEXT, _) => {
                println!("{:?} ({}) => {:?}: {}", envelope.sender, envelope.nickname, &envelope.recipient, String::from_utf8_lossy(msg));
                let _res = self.w.send_download_ack(envelope).await;
            }
            (TYPING_INDICATOR, 1) => {
                let x = if msg[0] == 1 {"is"} else {"has stopped"};
                println!("{} ({:?}) {} typing", envelope.nickname, envelope.sender, x);
            }
            (CONTACT_SET_PHOTO, 52) => {
                let blobref = blob_api::BlobRef::from_slice(msg);
                println!("CONTACT_SET_PHOTO, blob {:?}, {}", blobref, blobref.hex());
                //let res = blob_api::Client::new().download(&blobref).await;
                //println!(":) {:?}", res);
                
            }
            (unknown_type, unknown_length) => {
                eprintln!("Message with unknown type {} or length {}: {:?}", unknown_type, unknown_length, msg)
            }
        }
    }

Trait Implementations

impl Clone for BlobRef

fn clone(&self) -> BlobRef

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlobRef

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.