Int32
Fields d_int32 :: Int32
Int64
Fields d_int64 :: Int64
Float
Fields d_float :: Float
Double
Fields d_double :: Double
ASCII_String
Fields d_ascii_string :: ASCII
Blob
Fields d_blob :: ByteString
TimeStamp
Fields d_timestamp :: Time
Midi
Fields d_midi :: MIDI

Instances

Eq Datum
Read Datum
Show Datum

datum_tag :: Datum -> Datum_Type Source

Single character identifier of an OSC datum.

datum_integral :: Integral i => Datum -> Maybe i Source

Datum as Integral if Int32 or Int64.

let d = [Int32 5,Int64 5,Float 5.5,Double 5.5]
in map datum_integral d == [Just (5::Int),Just 5,Nothing,Nothing]

datum_floating :: Floating n => Datum -> Maybe n Source

Datum as Floating if Int32, Int64, Float, Double or TimeStamp.

let d = [Int32 5,Int64 5,Float 5,Double 5,TimeStamp 5]
in Data.Maybe.mapMaybe datum_floating d == replicate 5 (5::Double)

class Datem a where Source

Class for translating to and from Datum. There are instances for the direct Datum field types.

d_put (1::Int32) == Int32 1
d_put (1::Int64) == Int64 1
d_put (1::Float) == Float 1
d_put (1::Double) == Double 1
d_put (C.pack "str") == ASCII_String (C.pack "str")
d_put (B.pack [37,37]) == Blob (B.pack [37,37])
d_put (MIDI 0 0 0 0) == Midi (MIDI 0 0 0 0)

There are also instances for standard Haskell types.

d_put (1::Int) == Int64 1
d_put (1::Integer) == Int64 1

Methods

d_put :: a -> Datum Source

d_get :: Datum -> Maybe a Source

Instances

Datem Double
Datem Float
Datem Int
Datem Int32
Datem Int64
Datem Integer
Datem ByteString
Datem ByteString
Datem MIDI

int32 :: Integral n => n -> Datum Source

Type generalised Int32.

int32 (1::Int32) == int32 (1::Integer)
d_int32 (int32 (maxBound::Int32)) == maxBound
int32 (((2::Int) ^ (64::Int))::Int) == Int32 0

int64 :: Integral n => n -> Datum Source

Type generalised Int64.

int64 (1::Int32) == int64 (1::Integer)
d_int64 (int64 (maxBound::Int64)) == maxBound

float :: Real n => n -> Datum Source

Type generalised Float.

float (1::Int) == float (1::Double)
floatRange (undefined::Float) == (-125,128)
isInfinite (d_float (float (encodeFloat 1 256 :: Double))) == True

double :: Real n => n -> Datum Source

Type generalised Double.

double (1::Int) == double (1::Double)
double (encodeFloat 1 256 :: Double) == Double 1.157920892373162e77

string :: String -> Datum Source

ASCII_String of pack.

string "string" == ASCII_String (C.pack "string")

midi :: (Word8, Word8, Word8, Word8) -> Datum Source

Four-tuple variant of Midi . MIDI.

midi (0,0,0,0) == Midi (MIDI 0 0 0 0)

Message

type Address_Pattern = String Source

OSC address pattern. This is strictly an ASCII value, but it is very common to pattern match on addresses and matching on ByteString requires OverloadedStrings.

data Message Source

An OSC message.

Constructors

Message
Fields messageAddress :: Address_Pattern messageDatum :: [Datum]

Instances

Eq Message
Read Message
Show Message
OSC Message

message :: Address_Pattern -> [Datum] -> Message Source

Message constructor. It is an error if the Address_Pattern doesn't conform to the OSC specification.

descriptor :: [Datum] -> ASCII Source

Message argument types are given by a descriptor.

C.unpack (descriptor [Int32 1,Float 1,string "1"]) == ",ifs"

descriptor_tags :: ASCII -> ASCII Source

Descriptor tags are comma prefixed.

Bundle

data Bundle Source

An OSC bundle.

Constructors

Bundle
Fields bundleTime :: Time bundleMessages :: [Message]

Instances

Eq Bundle
Ord Bundle	OSC `Bundle`s can be ordered (time ascending).
Read Bundle
Show Bundle
OSC Bundle

bundle :: Time -> [Message] -> Bundle Source

Bundle constructor. It is an error if the Message list is empty.

Packet

data Packet Source

An OSC Packet is either a Message or a Bundle.

Constructors

Packet_Message
Fields packetMessage :: Message
Packet_Bundle
Fields packetBundle :: Bundle

Instances

Eq Packet
Read Packet
Show Packet
OSC Packet

p_bundle :: Time -> [Message] -> Packet Source

Packet_Bundle . bundle.

p_message :: Address_Pattern -> [Datum] -> Packet Source

Packet_Message . message.

packetTime :: Packet -> Time Source

The Time of Packet, if the Packet is a Message this is immediately.

packetMessages :: Packet -> [Message] Source

Retrieve the set of Messages from a Packet.

packet_to_bundle :: Packet -> Bundle Source

If Packet is a Message add immediately timestamp, else id.

packet_to_message :: Packet -> Maybe Message Source

If Packet is a Message or a Bundle with an immediate time tag and with one element, return the Message, else Nothing.

packet_is_immediate :: Packet -> Bool Source

Is Packet immediate, ie. a Bundle with timestamp immediately, or a plain Message.

at_packet :: (Message -> a) -> (Bundle -> a) -> Packet -> a Source

Variant of either for Packet.

Address Query

message_has_address :: Address_Pattern -> Message -> Bool Source

Does Message have the specified Address_Pattern.

bundle_has_address :: Address_Pattern -> Bundle -> Bool Source

Do any of the Messages at Bundle have the specified Address_Pattern.

packet_has_address :: Address_Pattern -> Packet -> Bool Source

Does Packet have the specified Address_Pattern, ie. message_has_address or bundle_has_address.

Pretty printing

type FP_Precision = Maybe Int Source

Perhaps a precision value for floating point numbers.

floatPP :: RealFloat n => Maybe Int -> n -> String Source

Variant of showFFloat that deletes trailing zeros.

map (floatPP (Just 4)) [1,pi] == ["1.0","3.1416"]

timePP :: FP_Precision -> Time -> String Source

Pretty printer for Time.

timePP (Just 4) (1/3) == "0.3333"

vecPP :: Show a => [a] -> String Source

Pretty printer for vectors.

vecPP [1::Int,2,3] == "<1,2,3>"

datumPP :: FP_Precision -> Datum -> String Source

Pretty printer for Datum.

let d = [Int32 1,Float 1.2,string "str",midi (0,0x90,0x40,0x60)]
in map datumPP d ==  ["1","1.2","\"str\"","<0,144,64,96>"]

messagePP :: FP_Precision -> Message -> String Source

Pretty printer for Message.

bundlePP :: FP_Precision -> Bundle -> String Source

Pretty printer for Bundle.

packetPP :: FP_Precision -> Packet -> String Source

Pretty printer for Packet.

Parser

readMaybe :: Read a => String -> Maybe a Source

Variant of read.

parse_datum :: Datum_Type -> String -> Maybe Datum Source

Given Datum_Type attempt to parse Datum at String.

parse_datum 'i' "42" == Just (Int32 42)
parse_datum 'h' "42" == Just (Int64 42)
parse_datum 'f' "3.14159" == Just (Float 3.14159)
parse_datum 'd' "3.14159" == Just (Double 3.14159)
parse_datum 's' "\"pi\"" == Just (string "pi")
parse_datum 'b' "[112,105]" == Just (Blob (B.pack [112,105]))
parse_datum 'm' "(0,144,60,90)" == Just (midi (0,144,60,90))