Struct String 

pub struct String<'a> { /* private fields */ }

A PostScript string object.

Implementations

impl<'a> String<'a>

pub fn decode_into(&self, out: &mut Vec<u8>) -> Result<()>

Decode the string content into out, replacing any previous contents.

pub fn decode(&self) -> Result<Vec<u8>>

Decode the string content.

Examples found in repository

examples/tokenize.rs (line 54)

fn print_object(object: &Object<'_>) {
    match object {
        Object::Number(Number::Integer(n)) => print!("Integer({n})"),
        Object::Number(Number::Real(n)) => print!("Real({n})"),
        Object::Name(name) => {
            let kind = if name.is_literal() {
                "literal"
            } else {
                "executable"
            };
            let text = name.as_str().unwrap_or("<non-ascii name>");
            print!("Name({text}, {kind})");
        }
        Object::String(s) => {
            let decoded = s.decode().unwrap_or_else(|_| Vec::new());
            print!("String({})", String::from_utf8_lossy(&decoded));
        }
        Object::Array(arr) => {
            print!("[");
            let mut inner = arr.objects();
            let mut first = true;
            while !inner.at_end() {
                if !first {
                    print!(" ");
                }
                first = false;
                match inner.parse_object() {
                    Ok(obj) => print_object(&obj),
                    Err(e) => print!("Error({e})"),
                }
            }
            print!("]");
        }
    }
}

Trait Implementations

impl<'a> Clone for String<'a>

fn clone(&self) -> String<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for String<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for String<'a>

fn eq(&self, other: &String<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Copy for String<'a>

impl<'a> Eq for String<'a>

impl<'a> StructuralPartialEq for String<'a>