Struct latin1str::Latin1String

#[repr(transparent)]
pub struct Latin1String { /* private fields */ }

An owned latin-1 encoded string

Implementations

impl Latin1String

pub const unsafe fn new(inner: Box<[u8]>) -> Self

Create a new string

Safety

Must not contain null bytes

pub fn encode(string: &str) -> Cow<'_, Latin1Str>

Create a new instance from a rust string.

Note: This encodes any unavailable unicode codepoints as their equivalent HTML-Entity. This is an implementation detail of the encoding_rs crate and not really useful for this crate.

use latin1str::Latin1String;

assert_eq!(Latin1String::encode("Hello World!").as_bytes(), b"Hello World!");
assert_eq!(Latin1String::encode("Frühling").as_bytes(), b"Fr\xFChling");

pub fn read_cstring<R: BufRead>(reader: &mut R) -> Result<Self, Error>

Create a new instance by reading from a BufRead until a null terminator is found or the end of the string is reached.

use std::io::{Read, Cursor};
use latin1str::Latin1String;

let bytes = b"Hello World!\0";
let mut cur = Cursor::new(bytes);
let s = Latin1String::read_cstring(&mut cur).unwrap();
assert_eq!(s.decode().as_ref(), "Hello World!");
assert_eq!(cur.read(&mut []).ok(), Some(0));

Methods from Deref<Target = Latin1Str>

pub fn as_bytes(&self) -> &[u8]

Get the bytes of the string

let s = Latin1Str::from_bytes_until_nul(b"Hello World!");
assert_eq!(s.as_bytes(), b"Hello World!")

Examples found in repository

src/lib.rs (line 190)

    fn to_owned(&self) -> Self::Owned {
        Latin1String {
            inner: self.as_bytes().into(),
        }
    }
}

impl Latin1Str {
    /// Turns some bytes into a Latin1Str slice
    ///
    /// ## Safety
    ///
    /// The byte slice may not contain any null bytes
    pub const unsafe fn from_bytes_unchecked(text: &[u8]) -> &Self {
        &*(text as *const [u8] as *const Latin1Str)
    }

    /// Wrap all bytes before the first nul as a [`Latin1Str`]
    ///
    /// This method will never fail
    ///
    /// ```
    /// # use latin1str::Latin1Str;
    /// let s = Latin1Str::from_bytes_until_nul(b"Hello\0World!");
    /// assert_eq!(s.as_bytes(), b"Hello");
    /// let s = Latin1Str::from_bytes_until_nul(b"Hello World!");
    /// assert_eq!(s.as_bytes(), b"Hello World!");
    /// ```
    pub fn from_bytes_until_nul(mut bytes: &[u8]) -> &Self {
        if let Some(nullpos) = memchr(0, bytes) {
            bytes = bytes.split_at(nullpos).0;
        }
        // SAFETY: if there was a nul in here, the if above would have removed it
        unsafe { Self::from_bytes_unchecked(bytes) }
    }

    #[deprecated = "Use `from_bytes_until_nul` instead"]
    /// Alias of [`Latin1Str::from_bytes_until_nul`]
    pub fn new(bytes: &[u8]) -> &Self {
        Self::from_bytes_until_nul(bytes)
    }

    /// Get the bytes of the string
    ///
    /// ```
    /// # use latin1str::Latin1Str;
    /// let s = Latin1Str::from_bytes_until_nul(b"Hello World!");
    /// assert_eq!(s.as_bytes(), b"Hello World!")
    /// ```
    pub const fn as_bytes(&self) -> &[u8] {
        &self.inner
    }

    /// Get the bytes of the string
    pub const fn len(&self) -> usize {
        self.inner.len()
    }

    /// Check whether the str is empty
    ///
    /// ```
    /// # use latin1str::Latin1Str;
    /// assert!(Latin1Str::from_bytes_until_nul(b"").is_empty());
    /// assert!(!Latin1Str::from_bytes_until_nul(b"a").is_empty());
    /// ```
    pub const fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }

    /// Decode the string
    ///
    /// ```
    /// # use latin1str::Latin1Str;
    /// let s = Latin1Str::from_bytes_until_nul(b"Fr\xFChling");
    /// assert_eq!(s.decode().as_ref(), "Frühling");
    /// ```
    pub fn decode(&self) -> Cow<str> {
        WINDOWS_1252.decode(self.as_bytes()).0
    }

pub fn len(&self) -> usize

Get the bytes of the string

pub fn is_empty(&self) -> bool

Check whether the str is empty

assert!(Latin1Str::from_bytes_until_nul(b"").is_empty());
assert!(!Latin1Str::from_bytes_until_nul(b"a").is_empty());

pub fn decode(&self) -> Cow<'_, str>

Decode the string

let s = Latin1Str::from_bytes_until_nul(b"Fr\xFChling");
assert_eq!(s.decode().as_ref(), "Frühling");

Examples found in repository

src/lib.rs (line 181)

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

Trait Implementations

impl Borrow<Latin1Str> for Latin1String

fn borrow(&self) -> &Latin1Str

Immutably borrows from an owned value.

impl Clone for Latin1String

fn clone(&self) -> Latin1String

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Deref for Latin1String

type Target = Latin1Str

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<&Latin1Str> for Latin1String

fn from(src: &Latin1Str) -> Latin1String

Converts to this type from the input type.

impl From<Cow<'_, Latin1Str>> for Latin1String

fn from(cow: Cow<'_, Latin1Str>) -> Self

Converts to this type from the input type.

impl Ord for Latin1String

fn cmp(&self, other: &Latin1String) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<&Latin1Str> for Latin1String

fn eq(&self, other: &&Latin1Str) -> 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 PartialEq<Latin1Str> for Latin1String

fn eq(&self, other: &Latin1Str) -> 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 PartialEq<Latin1String> for &Latin1Str

fn eq(&self, other: &Latin1String) -> 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 PartialEq<Latin1String> for Latin1Str

fn eq(&self, other: &Latin1String) -> 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 PartialEq<Latin1String> for Latin1String

fn eq(&self, other: &Latin1String) -> 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 PartialOrd<Latin1String> for Latin1String

fn partial_cmp(&self, other: &Latin1String) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Latin1String

impl StructuralEq for Latin1String

impl StructuralPartialEq for Latin1String