Struct Object

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

The anonymous object type of AMF. This consists of pairs of string keys and any AMF data types.

• Key

The string which doesn’t have its marker. This type is named as UnmarkedString in this crate. Also this occurs the panic if its length exceeds the range of 16 bits.

• Value

The pointer for AMF data types, which is wrapped into Arc. This is because of avoiding to be deallocated its value unexpectedly.

You can access to properties which this constains, as the HashMap.

Example

use sheave_core::{
    messages::amf::v0::AmfString,
    object
};

let mut object = object!(
    "app" => AmfString::from("ondemand")
);
object.get_properties().get("app");
&object.get_properties()["app"];

Implementations

impl Object

pub fn new(properties: Properties) -> Self

Constrcuts a new object.

pub fn get_properties(&self) -> &Properties

Gets immutable properties from this object.

pub fn get_properties_mut(&mut self) -> &mut Properties

Gets mutable properties from this object.

Trait Implementations

impl Clone for Object

fn clone(&self) -> Object

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Object

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

Formats the value using the given formatter.

impl Decoder<Object> for ByteBuffer

fn decode(&mut self) -> IOResult<Object>

Decodes bytes into an AMF’s Object type.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 2 bytes. (non-empty object contains at least one pair of key and value)

• InconsistentMarker

When a marker byte doesn’t indicate the AMF Object.

• InvalidString

When key bytes are invalid for a UTF-8 string.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    messages::amf::v0::{
        Marker,
        Object
    }
};

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Object as u8);
// AMF's Object type is required a marker of object end (0x09) which is associated with an empty key.
buffer.put_u16_be(0);
buffer.put_u8(Marker::ObjectEnd as u8);
assert!(Decoder::<Object>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Number as u8);
buffer.put_u16_be(0);
buffer.put_u8(Marker::ObjectEnd as u8);
assert!(Decoder::<Object>::decode(&mut buffer).is_err());

// This is a missing sequence of the "sparkle heart(💖)".
let mut bytes = vec![0, 159, 146, 150];
let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Object as u8);
buffer.put_u16_be(4);
buffer.put_bytes(&bytes);
buffer.put_u8(Marker::Number as u8);
buffer.put_f64(0.0);
buffer.put_u16_be(0);
buffer.put_u8(Marker::ObjectEnd as u8);
assert!(Decoder::<Object>::decode(&mut buffer).is_err());

let mut buffer = ByteBuffer::default();
assert!(Decoder::<Object>::decode(&mut buffer).is_err())

impl Default for Object

fn default() -> Object

Returns the “default value” for a type.

impl Encoder<Object> for ByteBuffer

fn encode(&mut self, object: &Object)

Encodes an AMF’s Object into bytes.

impl From<Connect> for Object

fn from(connect: Connect) -> Self

Converts to this type from the input type.

impl From<OnStatus> for Object

fn from(on_status: OnStatus) -> Self

Converts to this type from the input type.

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