pub use rosc;
pub use self::recv::Receiver;
#[doc(inline)]
pub use self::rosc::{
address, decoder, encoder, OscArray as Array, OscBundle as Bundle, OscColor as Color,
OscError as Error, OscMessage as Message, OscMidiMessage as MidiMessage, OscTime as Time,
OscTimeError as TimeError, OscType as Type,
};
pub use self::send::Sender;
use std;
use std::net::{Ipv4Addr, SocketAddr};
pub mod recv;
pub mod send;
pub struct Unconnected;
pub struct Connected {
addr: SocketAddr,
}
#[derive(Clone, Debug, PartialEq)]
pub enum Packet {
Message(Message),
Bundle(Bundle),
}
impl From<Message> for Packet {
fn from(msg: Message) -> Self {
Packet::Message(msg)
}
}
impl From<Bundle> for Packet {
fn from(bundle: Bundle) -> Self {
Packet::Bundle(bundle)
}
}
impl From<rosc::OscPacket> for Packet {
fn from(packet: rosc::OscPacket) -> Self {
match packet {
rosc::OscPacket::Message(msg) => msg.into(),
rosc::OscPacket::Bundle(bundle) => bundle.into(),
}
}
}
impl<A> From<(A, Vec<Type>)> for Packet
where
A: Into<String>,
{
fn from((addr, args): (A, Vec<Type>)) -> Self {
msg(addr, args).into()
}
}
impl Into<rosc::OscPacket> for Packet {
fn into(self) -> rosc::OscPacket {
match self {
Packet::Message(msg) => rosc::OscPacket::Message(msg),
Packet::Bundle(bundle) => rosc::OscPacket::Bundle(bundle),
}
}
}
impl Packet {
pub fn unfold(self, msgs: &mut Vec<Message>) {
match self {
Packet::Message(msg) => msgs.push(msg),
Packet::Bundle(bundle) => {
for packet in bundle.content {
Packet::unfold(packet.into(), msgs);
}
}
}
}
pub fn into_msgs(self) -> Vec<Message> {
let mut msgs = vec![];
self.unfold(&mut msgs);
msgs
}
}
pub fn default_ipv4_addr() -> Ipv4Addr {
Ipv4Addr::new(0, 0, 0, 0)
}
pub fn receiver(port: u16) -> Result<Receiver, std::io::Error> {
Receiver::bind(port)
}
pub fn sender() -> Result<Sender, std::io::Error> {
Sender::bind()
}
pub fn msg<A>(addr: A, args: Vec<Type>) -> Message
where
A: Into<String>,
{
let addr = addr.into();
Message { addr, args }
}
pub fn decode(bytes: &[u8]) -> Result<Packet, Error> {
rosc::decoder::decode_udp(bytes).map(|(_bytes, p)| p.into())
}
pub fn encode(packet: Packet) -> Result<Vec<u8>, Error> {
let rosc_packet = packet.into();
rosc::encoder::encode(&rosc_packet)
}
#[derive(Debug)]
pub enum CommunicationError {
Io(std::io::Error),
Osc(Error),
Poisoned,
}
impl From<std::io::Error> for CommunicationError {
fn from(err: std::io::Error) -> Self {
CommunicationError::Io(err)
}
}
impl From<Error> for CommunicationError {
fn from(err: Error) -> Self {
CommunicationError::Osc(err)
}
}
impl<T> From<std::sync::PoisonError<T>> for CommunicationError {
fn from(_: std::sync::PoisonError<T>) -> Self {
CommunicationError::Poisoned
}
}
impl std::error::Error for CommunicationError {
fn cause(&self) -> Option<&dyn std::error::Error> {
match *self {
CommunicationError::Io(ref err) => Some(err),
CommunicationError::Osc(ref _err) => None,
_ => None,
}
}
}
impl std::fmt::Display for CommunicationError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match *self {
CommunicationError::Io(ref err) => std::fmt::Display::fmt(err, f),
CommunicationError::Osc(ref _err) => write!(f, "Failed to decode the OSC packet"),
CommunicationError::Poisoned => write!(f, "The inner buffer's mutex was poisoned"),
}
}
}