Struct Object

pub struct Object(/* private fields */);

👎Deprecated since 0.1.4: rpsl-parser was renamed to rpsl-rs, please use that crate instead.

Represents a RPSL object.

Examples

Create a new role object

let role_acme = rpsl::Object::new(vec![
    rpsl::Attribute::new("role".to_string(), vec![Some("ACME Company".to_string())]),
    rpsl::Attribute::new(
        "address".to_string(),
        vec![Some("Packet Street 6".to_string())],
    ),
    rpsl::Attribute::new(
        "address".to_string(),
        vec![Some("128 Series of Tubes".to_string())],
    ),
    rpsl::Attribute::new("address".to_string(), vec![Some("Internet".to_string())]),
    rpsl::Attribute::new(
        "email".to_string(),
        vec![Some("rpsl-parser@github.com".to_string())],
    ),
    rpsl::Attribute::new("nic-hdl".to_string(), vec![Some("RPSL1-RIPE".to_string())]),
    rpsl::Attribute::new("source".to_string(), vec![Some("RIPE".to_string())]),
]);

And then print the email attribute by it’s index

println!("{:#?}", role_acme[4]);

Implementations

impl Object

pub fn new(attributes: Vec<Attribute>) -> Self

👎Deprecated since 0.1.4: rpsl-parser was renamed to rpsl-rs, please use that crate instead.

Create a new RPSL object from a vector of attributes.

Trait Implementations

impl Debug for Object

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

Formats the value using the given formatter.

impl From<Vec<(&str, Vec<&str>)>> for Object

fn from(attribute_slices: Vec<(&str, Vec<&str>)>) -> Self

Converts to this type from the input type.

impl Index<usize> for Object

type Output = Attribute

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for Object

type Item = Attribute

The type of the elements being iterated over.

type IntoIter = IntoIter<Attribute>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Object

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

impl StructuralPartialEq for Object