Struct ByteBuffer

pub struct ByteBuffer { /* private fields */ }

The stream buffer for encoding/decoding chunk data.

Implementations

impl ByteBuffer

pub fn remained(&self) -> usize

Computes remained length in this buffer.

pub fn peek_u8(&self) -> IOResult<u8>

Peeks 1 byte from buffer. This keeps buffer’s current offset.

Errors

• InSufficientBufferLength

When buffer isn’t remained at least 1 byte.

Examples

use rand::random;
use sheave_core::ByteBuffer;

let n = random::<u8>();
let mut buffer: ByteBuffer = n.to_be_bytes().to_vec().into();
assert!(buffer.peek_u8().is_ok());
let bytes: Vec<u8> = buffer.into();
// Buffer isn't consumed.
assert_eq!(n.to_be_bytes().as_slice(), &bytes);

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.peek_u8().is_err());

pub fn get_u8(&mut self) -> IOResult<u8>

Tries getting 1 byte from buffer.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 1 byte.

Examples

use rand::random;
use sheave_core::ByteBuffer;

let mut buffer: ByteBuffer  = random::<u8>().to_be_bytes().to_vec().into();
assert!(buffer.get_u8().is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_u8().is_err());

pub fn get_u16_be(&mut self) -> IOResult<u16>

Tries getting 2 bytes from buffer, as the big endian.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 2 bytes.

Examples

use rand::random;
use sheave_core::ByteBuffer;

let mut buffer: ByteBuffer = random::<u16>().to_be_bytes().to_vec().into();
assert!(buffer.get_u16_be().is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_u16_be().is_err());

pub fn get_i24_be(&mut self) -> IOResult<i32>

Tries getting signed 3 bytes from buffer, as the big endian.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 2 bytes.

Examples

use rand::{
    Fill,
    thread_rng
};
use sheave_core::ByteBuffer;

let mut bytes: [u8; 3] = [0; 3];
bytes.try_fill(&mut thread_rng()).unwrap();
let mut buffer: ByteBuffer = bytes.to_vec().into();
assert!(buffer.get_i24_be().is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_i24_be().is_err());

pub fn get_u24_be(&mut self) -> IOResult<u32>

Tries getting 3 bytes from buffer, as the big endian.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 2 bytes.

Examples

use rand::{
    Fill,
    thread_rng
};
use sheave_core::ByteBuffer;

let mut bytes: [u8; 3] = [0; 3];
bytes.try_fill(&mut thread_rng()).unwrap();
let mut buffer: ByteBuffer = bytes.to_vec().into();
assert!(buffer.get_u24_be().is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_u24_be().is_err());

pub fn get_u32_be(&mut self) -> IOResult<u32>

Tries getting 4 bytes from buffer, as the big endian.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 4 bytes.

Examples

use rand::random;
use sheave_core::ByteBuffer;

let mut buffer: ByteBuffer = random::<u32>().to_be_bytes().to_vec().into();
assert!(buffer.get_u32_be().is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_u32_be().is_err());

pub fn get_f64(&mut self) -> IOResult<f64>

Tries getting 8 bytes from buffer, as a 64 bits floating point number.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 8 bytes.

Examples

use rand::random;
use sheave_core::ByteBuffer;

let mut buffer: ByteBuffer = random::<u64>().to_be_bytes().to_vec().into();
assert!(buffer.get_f64().is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_f64().is_err());

pub fn get_bytes(&mut self, len: usize) -> IOResult<&[u8]>

Tries getting arbitrary bytes from buffer.

Erorrs

• InsufficientBufferLength

When buffer isn’t remained at least specified length.

Examples

use sheave_core::ByteBuffer;

let bytes = "hello world!".as_bytes();
let mut buffer: ByteBuffer = bytes.to_vec().into();
assert!(buffer.get_bytes(bytes.len()).is_ok());

let mut buffer: ByteBuffer = Vec::new().into();
assert!(buffer.get_bytes(bytes.len()).is_err())

pub fn put_u8(&mut self, n: u8)

Puts 1 byte into buffer.

pub fn put_u16_be(&mut self, n: u16)

Puts 2 bytes into buffer, as the big endian.

pub fn put_i24_be(&mut self, n: i32)

Puts signed 3 bytes into buffer, as the big endian.

Panics

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

Examples

use std::panic::catch_unwind;

let result = catch_unwind(
    || {
        use sheave_core::ByteBuffer;

        let mut buffer = ByteBuffer::default();
        buffer.put_i24_be((0x00ffffff + 1) as i32);
    }
);
assert!(result.is_err())

pub fn put_u24_be(&mut self, n: u32)

Puts 3 bytes into buffer, as the big endian.

Panics

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

Examples

use std::panic::catch_unwind;

let result = catch_unwind(
    || {
        use sheave_core::ByteBuffer;

        let mut buffer = ByteBuffer::default();
        buffer.put_u24_be((0x00ffffff + 1) as u32);
    }
);
assert!(result.is_err())

pub fn put_u32_be(&mut self, n: u32)

Puts 4 bytes into buffer, as the big endian.

pub fn put_f64(&mut self, n: f64)

Puts 8 bytes into buffer, as a 64 bits floating point number.

pub fn put_bytes(&mut self, bytes: &[u8])

Puts arbitrary bytes into buffer.

Trait Implementations

impl Clone for ByteBuffer

fn clone(&self) -> ByteBuffer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ByteBuffer

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

Formats the value using the given formatter.

impl Decoder<Acknowledgement> for ByteBuffer

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

Decodes bytes into a Acknowledgement message.

Errors

• InsufficientBufferLength

When this buffer didn’t remain at least 4 bytes.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    messages::{
        Acknowledgement
    }
};

let mut buffer = ByteBuffer::default();
buffer.put_u32_be(u32::default());
assert!(Decoder::<Acknowledgement>::decode(&mut buffer).is_ok())

impl Decoder<AmfString> for ByteBuffer

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

Decodes bytes into an AMF’s String.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 3 bytes.

• InconsistentMarker

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

• InvalidString

When bytes are invalid for a UTF-8 string.

Examples

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

let s = "hello world!".as_bytes();
let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::AmfString as u8);
buffer.put_u16_be(s.len() as u16);
buffer.put_bytes(s);
assert!(Decoder::<AmfString>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Number as u8);
buffer.put_u16_be(s.len() as u16);
buffer.put_bytes(s);
assert!(Decoder::<AmfString>::decode(&mut buffer).is_err());

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

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

impl Decoder<Audio> for ByteBuffer

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

impl Decoder<AudioTag> for ByteBuffer

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

Decodes bytes into a AudioTag.

Errors

• InsufficientBufferLength

When some field misses.

Examples

use rand::{
    Fill,
    thread_rng
};
use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    flv::tags::{
        AudioTag,
        AudioTagHeader,
        SoundFormat,
        SoundRate
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&AudioTagHeader::new(SoundFormat::LinearPcmNe, SoundRate::FivePointFive, false, false, None));
let mut bytes: [u8; 127] = [0; 127];
bytes.try_fill(&mut thread_rng()).unwrap();
buffer.put_bytes(&bytes);
assert!(Decoder::<AudioTag>::decode(&mut buffer).is_ok());

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

impl Decoder<AudioTagHeader> for ByteBuffer

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

Decodes bytes into a AudioTagHeader.

Errors

• InsufficientBufferLength

When some field misses.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    flv::tags::AudioTagHeader
};

let mut buffer = ByteBuffer::default();
buffer.put_u8(0);
assert!(Decoder::<AudioTagHeader>::decode(&mut buffer).is_ok());

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

impl Decoder<Boolean> for ByteBuffer

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

Decodes bytes into an AMF’s Boolean.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 2 bytes.

• InconsistentMarker

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

Examples

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

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Boolean as u8);
buffer.put_u8(0);
assert!(Decoder::<Boolean>::decode(&mut buffer).is_ok());

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

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

impl Decoder<ChunkSize> for ByteBuffer

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

Decodes bytes into a ChunkSize.

Errors

• Insufficientbufferlength

When chunk data didn’t remain at least 4 bytes.

• NegativeChunkSize

When its received chunk size’s most significant bit is 1. Chunking size is required that its bit is 0 in the specification. This is probably considered of programs which has no unsigned type.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    messages::ChunkSize
};

let mut buffer = ByteBuffer::default();
buffer.put_u32_be(128);
assert!(Decoder::<ChunkSize>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.put_u32_be(0x80000000);
assert!(Decoder::<ChunkSize>::decode(&mut buffer).is_err());

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

impl Decoder<Connect> for ByteBuffer

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

Decodes bytes into a Connect command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

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

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

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

impl Decoder<ConnectResult> for ByteBuffer

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

Decodes bytes into a ConnectResult command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

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

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

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

impl Decoder<CreateStream> for ByteBuffer

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

Decodes bytes into a CreateStream command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        CreateStream,
        amf::v0::Null,
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
assert!(Decoder::<CreateStream>::decode(&mut buffer).is_ok());

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

impl Decoder<CreateStreamResult> for ByteBuffer

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

Decodes bytes into a CreateStreamResult command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        CreateStreamResult,
        amf::v0::{
            Number,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&Number::default());
assert!(Decoder::<CreateStreamResult>::decode(&mut buffer).is_ok());

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

impl Decoder<DeleteStream> for ByteBuffer

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

Decodes bytes into a DeleteStream command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        DeleteStream,
        amf::v0::{
            Number,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&Number::default());
assert!(Decoder::<DeleteStream>::decode(&mut buffer).is_ok());

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

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 Decoder<FcPublish> for ByteBuffer

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

Decodes bytes into a FcPublish command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

• InvalidString

When some value is invalid for UTF-8 string.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        FcPublish,
        amf::v0::{
            AmfString,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
assert!(Decoder::<FcPublish>::decode(&mut buffer).is_ok());

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

impl Decoder<FcUnpublish> for ByteBuffer

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

Decodes bytes into a FcUnpublish command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

• InvalidString

When some value is invalid for UTF-8 string.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        FcUnpublish,
        amf::v0::{
            AmfString,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
assert!(Decoder::<FcUnpublish>::decode(&mut buffer).is_ok());

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

impl Decoder<Null> for ByteBuffer

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

Decodes bytes into an AMF’s Null.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 1 byte.

• InconsistentMarker

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

Examples

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

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Null as u8);
assert!(Decoder::<Null>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Boolean as u8);
assert!(Decoder::<Null>::decode(&mut buffer).is_err());

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

impl Decoder<Number> for ByteBuffer

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

Decodes bytes into an AMF’s Number.

Errors

• InsufficientBufferLength

When buffer isn’t remained at least 9 bytes.

• InconsistentMarker

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

Examples

use rand::random;
use sheave_core::{
    ByteBuffer,
    Decoder,
    messages::amf::v0::{
        Marker,
        Number
    }
};

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Number as u8);
buffer.put_f64(f64::from_bits(random::<u64>()));
assert!(Decoder::<Number>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.put_u8(Marker::Boolean as u8);
buffer.put_f64(f64::from_bits(random::<u64>()));
assert!(Decoder::<Number>::decode(&mut buffer).is_err());

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

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 Decoder<OnFcPublish> for ByteBuffer

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

Decodes bytes into an OnFcPublish command.

impl Decoder<OnStatus> for ByteBuffer

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

Decodes bytes into an OnStatus command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        OnStatus,
        amf::v0::{
            Object,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&Object::default());
assert!(Decoder::<OnStatus>::decode(&mut buffer).is_ok());

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

impl Decoder<PeerBandwidth> for ByteBuffer

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

Decodes bytes into a PeerBandwidth message.

Errors

• InsufficientBufferLength

When this buffer didn’t remain at least 5 bytes.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    messages::PeerBandwidth
};

let mut buffer = ByteBuffer::default();
buffer.put_u32_be(u32::default());
buffer.put_u8(u8::default());
assert!(Decoder::<PeerBandwidth>::decode(&mut buffer).is_ok())

impl Decoder<Publish> for ByteBuffer

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

Decodes bytes into a Publish command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

• InvalidString

When some value is invalid for UTF-8 string.

• InvalidPublishingType

When the publishing type is neither "live", "record" nor "append".

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        Publish,
        amf::v0::{
            AmfString,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
buffer.encode(&AmfString::from("live"));
assert!(Decoder::<Publish>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
buffer.encode(&AmfString::from("record"));
assert!(Decoder::<Publish>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
buffer.encode(&AmfString::from("append"));
assert!(Decoder::<Publish>::decode(&mut buffer).is_ok());

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
buffer.encode(&AmfString::from("something else"));
assert!(Decoder::<Publish>::decode(&mut buffer).is_err())

impl Decoder<ReleaseStream> for ByteBuffer

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

Decodes bytes into a ReleaseStream command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

• InvalidString

When some value is invalid for UTF-8 string.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        ReleaseStream,
        amf::v0::{
            AmfString,
            Null
        }
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
buffer.encode(&AmfString::default());
assert!(Decoder::<ReleaseStream>::decode(&mut buffer).is_ok());

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

impl Decoder<ReleaseStreamResult> for ByteBuffer

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

Decodes bytes into a ReleaseStreamResult command.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        ReleaseStreamResult,
        amf::v0::Null,
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&Null);
assert!(Decoder::<ReleaseStreamResult>::decode(&mut buffer).is_ok());

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

impl Decoder<ScriptDataTag> for ByteBuffer

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

Decodes bytes into a ScriptDataTag.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

• InvalidString

When some value is invalid for UTF-8 string.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    flv::tags::ScriptDataTag,
    messages::amf::v0::{
        AmfString,
        EcmaArray
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&AmfString::from("onMetaData"));
buffer.encode(&EcmaArray::default());
assert!(Decoder::<ScriptDataTag>::decode(&mut buffer).is_ok());

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

impl Decoder<SetDataFrame> for ByteBuffer

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

Decodes bytes into a SetDataFrame message.

Errors

• InsufficientBufferLength

When some field misses.

• InconsistentMarker

When some value is inconsistent with its marker.

• InvalidString

When some value is invalid for UTF-8 string.

• InconsistentCommand

When the command name isn’t "@setDataFrame".

Examples

use rand::{
    Fill,
    thread_rng
};
use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::SetDataFrame
};

let mut buffer = ByteBuffer::default();
let mut bytes: [u8; 128] = [0; 128];
bytes.try_fill(&mut thread_rng()).unwrap();
buffer.put_bytes(&bytes);
assert!(Decoder::<SetDataFrame>::decode(&mut buffer).is_ok());

impl Decoder<StreamBegin> for ByteBuffer

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

Decodes bytes into a StreamBegin event.

Errors

• InsufficientBufferLength

When some field misses.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    messages::{
        EventType,
        StreamBegin
    }
};

let mut buffer = ByteBuffer::default();
buffer.put_u32_be(u32::default());
assert!(Decoder::<StreamBegin>::decode(&mut buffer).is_ok());

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

impl Decoder<Video> for ByteBuffer

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

impl Decoder<VideoTag> for ByteBuffer

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

Decodes bytes into a VideoTag.

Errors

• InsufficientBufferLength

When some field misses.

Examples

use rand::{
    Fill,
    thread_rng
};
use sheave_core::{
    ByteBuffer,
    Decoder,
    Encoder,
    flv::tags::{
        VideoTag,
        VideoTagHeader,
        FrameType,
        Codec,
        AvcPacketType
    }
};

let mut buffer = ByteBuffer::default();
buffer.encode(&VideoTagHeader::new(FrameType::Disposable, Codec::H263, None, None));
let mut bytes: [u8; 127] = [0; 127];
bytes.try_fill(&mut thread_rng()).unwrap();
buffer.put_bytes(&bytes);
assert!(Decoder::<VideoTag>::decode(&mut buffer).is_ok());

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

impl Decoder<VideoTagHeader> for ByteBuffer

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

Decodes bytes into a VideoTagHeader.

Errors

• InsufficientBufferLength

When some field misses.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    flv::tags::VideoTagHeader
};

let mut buffer = ByteBuffer::default();
buffer.put_u8(0x32);
assert!(Decoder::<VideoTagHeader>::decode(&mut buffer).is_ok());

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

impl Decoder<WindowAcknowledgementSize> for ByteBuffer

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

Decodes bytes into an WindowAcknowledgementSize message.

Errors

• InsufficientBufferLength

When this buffer didn’t remain at least 4 bytes.

Examples

use sheave_core::{
    ByteBuffer,
    Decoder,
    messages::WindowAcknowledgementSize
};

let mut buffer = ByteBuffer::default();
buffer.put_u32_be(u32::default());
assert!(Decoder::<WindowAcknowledgementSize>::decode(&mut buffer).is_ok())

impl Default for ByteBuffer

fn default() -> ByteBuffer

Returns the “default value” for a type.

impl Encoder<Acknowledgement> for ByteBuffer

fn encode(&mut self, acknowledgement: &Acknowledgement)

Encodes a Acknowledgement message into bytes.

impl Encoder<AmfString> for ByteBuffer

fn encode(&mut self, string: &AmfString)

Encodes an AMF String into bytes.

Panics

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

Examples

use std::panic::catch_unwind;
use sheave_core::{
    ByteBuffer,
    Encoder,
    messages::amf::v0::{
        Marker,
        AmfString
    }
};

let s = "hello world!";
let mut buffer = ByteBuffer::default();
buffer.encode(&AmfString::from(s));
let bytes: Vec<u8> = buffer.into();
assert_eq!(Marker::AmfString as u8, bytes[0]);
assert_eq!((s.len() as u16).to_be_bytes().as_slice(), &bytes[1..3]);
assert_eq!(s.as_bytes(), &bytes[3..]);

let result = catch_unwind(
    || {
        let mut buffer = ByteBuffer::default();
        buffer.encode(&AmfString::new("a".repeat(1 + u16::MAX as usize)))
    }
);
assert!(result.is_err())

impl Encoder<Audio> for ByteBuffer

fn encode(&mut self, audio: &Audio)

impl Encoder<AudioTag> for ByteBuffer

fn encode(&mut self, audio_tag: &AudioTag)

Encodes a AudioTag into bytes.

impl Encoder<AudioTagHeader> for ByteBuffer

fn encode(&mut self, audio_tag_header: &AudioTagHeader)

Encodes a AudioTagHeader into bytes.

impl Encoder<Boolean> for ByteBuffer

fn encode(&mut self, boolean: &Boolean)

Encodes an AMF’s Boolean into bytes.

impl Encoder<ChunkSize> for ByteBuffer

fn encode(&mut self, chunk_size: &ChunkSize)

Encodes a ChunkSize into bytes.

impl Encoder<Connect> for ByteBuffer

fn encode(&mut self, connect: &Connect)

Encodes a Connect command into bytes.

impl Encoder<ConnectResult> for ByteBuffer

fn encode(&mut self, connect_result: &ConnectResult)

Encodes a ConnectResult command into bytes.

impl Encoder<CreateStream> for ByteBuffer

fn encode(&mut self, _: &CreateStream)

Encodes a CreateSteam command into bytes.

impl Encoder<CreateStreamResult> for ByteBuffer

fn encode(&mut self, create_stream_result: &CreateStreamResult)

Encodes a CreateStreamResult command into bytes.

impl Encoder<DeleteStream> for ByteBuffer

fn encode(&mut self, delete_stream: &DeleteStream)

Encodes a DeleteStream command into bytes.

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 Encoder<FcPublish> for ByteBuffer

fn encode(&mut self, fc_publish: &FcPublish)

Encodes a FcPublish command into bytes.

impl Encoder<FcUnpublish> for ByteBuffer

fn encode(&mut self, fc_unpublish: &FcUnpublish)

Encodes a FcUnpublish command into bytes.

impl Encoder<Null> for ByteBuffer

fn encode(&mut self, _: &Null)

Encodes an AMF’s Null into bytes.

impl Encoder<Number> for ByteBuffer

fn encode(&mut self, n: &Number)

Encodes an AMF’s Number into bytes.

impl Encoder<Object> for ByteBuffer

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

Encodes an AMF’s Object into bytes.

impl Encoder<OnFcPublish> for ByteBuffer

fn encode(&mut self, _: &OnFcPublish)

Encodes an OnFcPublish command into bytes. However this encodes nothing because has no field.

impl Encoder<OnStatus> for ByteBuffer

fn encode(&mut self, on_status: &OnStatus)

Encodes an OnStatus command into bytes.

impl Encoder<PeerBandwidth> for ByteBuffer

fn encode(&mut self, peer_bandwidth: &PeerBandwidth)

Encodes a PeerBandwidth message into bytes.

impl Encoder<Publish> for ByteBuffer

fn encode(&mut self, publish: &Publish)

Encodes a Publish command into bytes.

impl Encoder<ReleaseStream> for ByteBuffer

fn encode(&mut self, release_stream: &ReleaseStream)

Encodes a ReleaseStream command into bytes.

impl Encoder<ReleaseStreamResult> for ByteBuffer

fn encode(&mut self, _: &ReleaseStreamResult)

Encodes a ReleaseStreamResult command into bytes.

impl Encoder<ScriptDataTag> for ByteBuffer

fn encode(&mut self, script_data: &ScriptDataTag)

Encodes a ScriptDataTag into bytes.

impl Encoder<SetDataFrame> for ByteBuffer

fn encode(&mut self, set_data_frame: &SetDataFrame)

Encodes a SetDataFrame message into bytes.

impl Encoder<StreamBegin> for ByteBuffer

fn encode(&mut self, stream_begin: &StreamBegin)

Encodes a StreamBegin event into bytes.

impl Encoder<Video> for ByteBuffer

fn encode(&mut self, video: &Video)

impl Encoder<VideoTag> for ByteBuffer

fn encode(&mut self, video_tag: &VideoTag)

Encodes a VideoTag into bytes.

impl Encoder<VideoTagHeader> for ByteBuffer

fn encode(&mut self, video_tag_header: &VideoTagHeader)

Encodes a VideoTagHeader into bytes.

impl Encoder<WindowAcknowledgementSize> for ByteBuffer

fn encode(&mut self, window_acknowledgement_size: &WindowAcknowledgementSize)

Encodes an WindowAcknowledgementSize message into bytes.

impl From<ByteBuffer> for Vec<u8>

fn from(buffer: ByteBuffer) -> Self

Converts remained bytes into Vec.

Examples

use rand::{
    Fill,
    thread_rng
};
use sheave_core::ByteBuffer;

// When all byte is remained.
let mut array: [u8; 128] = [0; 128];
array.try_fill(&mut thread_rng()).unwrap();
let mut buffer = ByteBuffer::default();
buffer.put_bytes(&array);
let bytes: Vec<u8> = buffer.into();
assert_eq!(array.as_slice(), &bytes);

// When some bytes are consumed.
let mut array: [u8; 128] = [0; 128];
array.try_fill(&mut thread_rng()).unwrap();
let mut buffer = ByteBuffer::default();
buffer.put_bytes(&array);
buffer.get_u8().unwrap();
let bytes: Vec<u8> = buffer.into();
assert_eq!(&array[1..], &bytes)

impl From<Vec<u8>> for ByteBuffer

fn from(bytes: Vec<u8>) -> Self

Converts to this type from the input type.