Enum sodg::Hex

pub enum Hex {
    Vector(Vec<u8>),
    Bytes([u8; 24], usize),
}

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(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(65534);
assert_eq!(65534, d.to_i64().unwrap());

Variants

Vector(Vec<u8>)

Bytes([u8; 24], usize)

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 bytes(&self) -> &[u8]

Bytes contained.

use sodg::Hex;
let d = Hex::from(2);
assert_eq!(8, d.len())

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_slice(slice: &[u8]) -> Self

Create from slice, in appropriate mode.

use sodg::Hex;
let d = Hex::from_slice(&[0xDE, 0xAD]);
assert_eq!("DE-AD", d.print());
let v = Hex::from_slice(&vec![0xBE, 0xEF]);
assert_eq!("BE-EF", v.print());

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 from_string_bytes(d: String) -> Self

Make Hex from String.

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

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

Make hex from the bytes composing &str.

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

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 byte_at(&self, pos: usize) -> u8

Take one byte.

use sodg::Hex;
let d = Hex::from_str_bytes("你好");
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_bytes("Hello, world!");
assert_eq!("world!", d.tail(7).to_utf8().unwrap());

pub fn concat(&self, h: Self) -> Self

Create a new Hex, which is a concatenation of self and h.

use sodg::Hex;
let a = Hex::from_slice("dead".as_bytes());
let b = Hex::from_slice("beef".as_bytes());
let c = a.concat(b);
assert_eq!(c, Hex::from_slice("deadbeef".as_bytes()));

Trait Implementations

impl Clone for Hex

fn clone(&self) -> Hex

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 From<bool> for Hex

fn from(d: bool) -> Self

From bool.

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

impl From<f64> for Hex

fn from(d: f64) -> Self

Make Hex from f64.

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

impl From<i64> for Hex

fn from(d: i64) -> Self

Make Hex from i64.

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

impl FromStr for Hex

fn from_str(hex: &str) -> Result<Self, Self::Err>

Creeate a Hex from a &str containing a hexadecimal representation of some data, for example, DE-AD-BE-EF-20-22.

use sodg::Hex;
use std::str::FromStr;
let hex = "DE-AD-BE-EF-20-22";
let d: Hex = hex.parse().unwrap();
let d2 = Hex::from_str(hex).unwrap();
assert_eq!("DE-AD-BE-EF-20-22", d.print());
assert_eq!("DE-AD-BE-EF-20-22", d2.print());

type Err = Error

The associated error which can be returned from parsing.

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.

impl Eq for Hex