Struct tox_packet::toxid::ToxId

pub struct ToxId {
    pub pk: PublicKey,
    // some fields omitted
}

Tox ID.

Length	Contents
32	long term PublicKey
4	NoSpam
2	Checksum

https://zetok.github.io/tox-spec/#tox-id

Fields

pk: PublicKey

Long-term PublicKey.

Implementations

impl ToxId

pub fn checksum(PublicKey: &PublicKey, nospam: NoSpam) -> [u8; 2]

Checksum of PublicKey and NoSpam.

https://zetok.github.io/tox-spec/#tox-id , 4th paragraph.

E.g.

use tox_crypto::{
        gen_keypair,
        PublicKey,
        PUBLICKEYBYTES,
};
use tox_packet::toxid::{NoSpam, NOSPAMBYTES, ToxId};

let (pk, _) = gen_keypair();
let nospam = NoSpam::random();

let _checksum = ToxId::checksum(&pk, nospam);

assert_eq!(ToxId::checksum(&PublicKey([0; PUBLICKEYBYTES]),
           NoSpam([0; NOSPAMBYTES])), [0; 2]);
assert_eq!(ToxId::checksum(&PublicKey([0xff; PUBLICKEYBYTES]),
           NoSpam([0xff; NOSPAMBYTES])), [0; 2]);

pub fn new(pk: PublicKey) -> Self

Create new ToxId.

E.g.

use tox_crypto::gen_keypair;
use tox_packet::toxid::ToxId;

let (pk, _) = gen_keypair();
let _toxid = ToxId::new(pk);

pub fn new_nospam(&mut self, nospam: Option<NoSpam>)

Change NoSpam. If provided, change to provided value. If not provided (None), generate random NoSpam.

After NoSpam change PublicKey is always the same, but NoSpam and checksum differ:

use tox_crypto::gen_keypair;
use tox_packet::toxid::{NoSpam, ToxId};

let (pk, _) = gen_keypair();
let toxid = ToxId::new(pk);
let mut toxid2 = toxid;
toxid2.new_nospam(None);

assert_ne!(toxid, toxid2);
assert_eq!(toxid.pk, toxid2.pk);

let mut toxid3 = toxid;

// with same `NoSpam` IDs are identical
let nospam = NoSpam::random();
toxid2.new_nospam(Some(nospam));
toxid3.new_nospam(Some(nospam));
assert_eq!(toxid2, toxid3);

Trait Implementations

impl Clone for ToxId

pub fn clone(&self) -> ToxId

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for ToxId

impl Debug for ToxId

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

Formats the value using the given formatter.

impl Display for ToxId

Same as UpperHex.

E.g.

use tox_crypto::gen_keypair;
use tox_packet::toxid::ToxId;

let (pk, _) = gen_keypair();
let toxid = ToxId::new(pk);
assert_eq!(format!("{}", toxid), format!("{:X}", toxid));

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

Formats the value using the given formatter.

impl Eq for ToxId

impl FromBytes for ToxId

pub fn from_bytes(i: &[u8]) -> IResult<&[u8], ToxId, (&[u8], ErrorKind)>

Deserialize struct using nom from raw bytes

impl PartialEq<ToxId> for ToxId

pub fn eq(&self, other: &ToxId) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &ToxId) -> bool

This method tests for !=.

impl StructuralEq for ToxId

impl StructuralPartialEq for ToxId

impl ToBytes for ToxId

pub fn to_bytes<'a>(
    &self,
    buf: (&'a mut [u8], usize)
) -> Result<(&'a mut [u8], usize), GenError>

Serialize struct into raw bytes using cookie_factory

impl UpperHex for ToxId

The default formatting for ToxId.

E.g.

use tox_crypto::{PublicKey, PUBLICKEYBYTES};
use tox_packet::toxid::{NoSpam, NOSPAMBYTES, ToxId};

let mut toxid = ToxId::new(PublicKey([0; PUBLICKEYBYTES]));
toxid.new_nospam(Some(NoSpam([0; NOSPAMBYTES])));
// 76 `0`s
assert_eq!(&format!("{:X}", toxid),
    "0000000000000000000000000000000000000000000000000000000000000000000000000000");

let mut toxid = ToxId::new(PublicKey([255; PUBLICKEYBYTES]));
toxid.new_nospam(Some(NoSpam([255; NOSPAMBYTES])));
// 72 `F`s + 4 `0`s
assert_eq!(&format!("{:X}", toxid),
    "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000");

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

Formats the value using the given formatter.