Struct EcmaArray

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

The sized object type of AMF. This consists of:

• Count

The unsigned 32 bits integer.

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.

This is expected its size is same as the above count.

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

Examples

use sheave_core::{
    ecma_array,
    messages::amf::v0::{
        EcmaArray,
        Number
    },
};

let ecma_array = ecma_array!(
    "videocodecid" => Number::from(0)
);
ecma_array.get_properties().get("videocodecid");
&ecma_array.get_properties()["videocodecid"];

Implementations

impl EcmaArray

pub fn new(properties: Properties) -> Self

Constructs a new ECMA array.

pub fn get_properties(&self) -> &Properties

Gets immutable properties from this array.

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

Gets mutable properties from this array.

Trait Implementations

impl Clone for EcmaArray

fn clone(&self) -> EcmaArray

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EcmaArray

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

Formats the value using the given formatter.

impl Decoder<EcmaArray> for ByteBuffer

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

Decodes bytes into an ECMA array.

Errors

• InsufficientBufferLength

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

• InconsistentMarker

When a marker byte doesn’t indicate the ECMA array.

• InvalidString

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

Examples

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

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::EcmaArray as u8);
buffer.put_u32_be(0);
// Also ECMA array 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::<EcmaArray>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Number as u8);
buffer.put_u32_be(0);
buffer.put_u16_be(0);
buffer.put_u8(Marker::ObjectEnd as u8);
assert!(Decoder::<EcmaArray>::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::EcmaArray as u8);
buffer.put_u32_be(0);
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::<EcmaArray>::decode(&mut buffer).is_err());

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

Note the length field will not be so cared because to decodde is enough to check the object end marker (0x09). However warning will emit if lengths is inconsistent.

impl Default for EcmaArray

fn default() -> EcmaArray

Returns the “default value” for a type.

impl Encoder<EcmaArray> for ByteBuffer

fn encode(&mut self, ecma_array: &EcmaArray)

Encodes an ECMA array into bytes.

Panics

Its length must be the range of 32 bits. If it exceeds, a panic is occured.

impl From<SetPlaylist> for EcmaArray

fn from(set_playlist: SetPlaylist) -> Self

Converts to this type from the input type.

impl PartialEq for EcmaArray

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

impl StructuralPartialEq for EcmaArray