Struct sodg::Hex

pub struct Hex { /* private fields */ }

It is an object-oriented representation of binary data in hexadecimal format, which can be put into vertices of the graph. You can create it from Rust primitives:

use sodg::Hex;
let d = Hex::from_i64(65534);
assert_eq!("00-00-00-00-00-00-FF-FE", d.print());

Then, you can turn it back to Rust primitives:

use sodg::Hex;
let d = Hex::from_i64(65534);
assert_eq!(65534, d.to_i64().unwrap());

Implementations

impl Hex

pub fn empty() -> Self

Make an empty Hex.

use sodg::Hex;
let d = Hex::empty();
assert!(d.is_empty());
assert_eq!("--", d.print());

pub fn len(&self) -> usize

How many bytes in there.

use sodg::Hex;
let d = Hex::empty();
assert_eq!(0, d.len());

pub fn from_vec(bytes: Vec<u8>) -> Self

From Vec<u8>.

use sodg::Hex;
let d = Hex::from_vec(vec![0xCA, 0xFE]);
assert_eq!("CA-FE", d.print());

pub fn parse(hex: String) -> Self

From String as HEX, for example DE-AD-BE-EF-20-22.

use sodg::Hex;
let hex = "DE-AD-BE-EF-20-22";
let d = Hex::parse(hex.to_string());
assert_eq!("DE-AD-BE-EF-20-22", d.print());

pub fn from_i64(d: i64) -> Self

Make Hex from i64.

use sodg::Hex;
let d = Hex::from_i64(65536);
assert_eq!("00-00-00-00-00-01-00-00", d.print());

pub fn from_bool(d: bool) -> Self

From bool.

use sodg::Hex;
let d = Hex::from_bool(true);
assert_eq!("01", d.print());

pub fn from_f64(d: f64) -> Self

Make Hex from f64.

use std::f64::consts::PI;
use sodg::Hex;
let d = Hex::from_f64(PI);
assert_eq!("40-09-21-FB-54-44-2D-18", d.print());

pub fn from_string(d: String) -> Self

Make Hex from String.

use sodg::Hex;
let d = Hex::from_string("Ура!".to_string());
assert_eq!("D0-A3-D1-80-D0-B0-21", d.print());

pub fn from_str(d: &str) -> Self

From &str.

pub fn is_empty(&self) -> bool

It’s empty and no data?

use sodg::Hex;
let d = Hex::from_vec(vec![]);
assert_eq!(true, d.is_empty());

pub fn to_bool(&self) -> Result<bool>

Turn it into bool.

use sodg::Hex;
let d = Hex::from_vec([0x01].to_vec());
assert_eq!(true, d.to_bool().unwrap());

pub fn to_i64(&self) -> Result<i64>

Turn it into i64.

use sodg::Hex;
let d = Hex::from_vec([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2A].to_vec());
assert_eq!(42, d.to_i64().unwrap());

pub fn to_f64(&self) -> Result<f64>

Turn it into f64.

use sodg::Hex;
let d = Hex::from_vec([0x40, 0x09, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18].to_vec());
assert_eq!(std::f64::consts::PI, d.to_f64().unwrap());

pub fn to_utf8(&self) -> Result<String>

Turn it into string.

use sodg::Hex;
let d = Hex::from_vec([0x41, 0x42].to_vec());
assert_eq!("AB", d.to_utf8().unwrap());

pub fn print(&self) -> String

Turn it into a hexadecimal string.

use sodg::Hex;
let d = Hex::from_vec([0xCA, 0xFE].to_vec());
assert_eq!("CA-FE", d.print());

pub fn to_vec(&self) -> Vec<u8>

Turn it into a vector of bytes (making a clone).

pub fn as_vec(&self) -> &Vec<u8>

Return a reference to the encapsulated immutable vec.

pub fn byte_at(&self, pos: usize) -> u8

Take one byte.

use sodg::Hex;
let d = Hex::from_str("你好");
assert_eq!("E4-BD-A0-E5-A5-BD", d.print());
assert_eq!(0xA0, d.byte_at(2));

pub fn tail(&self, skip: usize) -> Self

Skip a few bytes at the beginning and return the rest as a new instance of Hex.

use sodg::Hex;
let d = Hex::from_str("Hello, world!");
assert_eq!("world!", d.tail(7).to_utf8().unwrap());

Trait Implementations

impl Clone for Hex

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Hex

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Hex

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

Formats the value using the given formatter.

impl PartialEq<Hex> for Hex

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Hex

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.