{- |
System Real Time messages
-}
module Sound.MIDI.Message.System.RealTime (
   T(..), get, put,
   ) where

import qualified Sound.MIDI.Parser.Class as Parser

import qualified Sound.MIDI.Writer.Basic as Writer

import Data.Ix(Ix)


data T =
     TimingClock                   -- F8
   | Start                         -- FA
   | Continue                      -- FB
   | Stop                          -- FC
   | ActiveSensing                 -- FE
   | Reset                         -- FF
   deriving (T -> T -> Bool
(T -> T -> Bool) -> (T -> T -> Bool) -> Eq T
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: T -> T -> Bool
== :: T -> T -> Bool
$c/= :: T -> T -> Bool
/= :: T -> T -> Bool
Eq, Eq T
Eq T =>
(T -> T -> Ordering)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> T)
-> (T -> T -> T)
-> Ord T
T -> T -> Bool
T -> T -> Ordering
T -> T -> T
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: T -> T -> Ordering
compare :: T -> T -> Ordering
$c< :: T -> T -> Bool
< :: T -> T -> Bool
$c<= :: T -> T -> Bool
<= :: T -> T -> Bool
$c> :: T -> T -> Bool
> :: T -> T -> Bool
$c>= :: T -> T -> Bool
>= :: T -> T -> Bool
$cmax :: T -> T -> T
max :: T -> T -> T
$cmin :: T -> T -> T
min :: T -> T -> T
Ord, Int -> T -> ShowS
[T] -> ShowS
T -> String
(Int -> T -> ShowS) -> (T -> String) -> ([T] -> ShowS) -> Show T
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> T -> ShowS
showsPrec :: Int -> T -> ShowS
$cshow :: T -> String
show :: T -> String
$cshowList :: [T] -> ShowS
showList :: [T] -> ShowS
Show, Int -> T
T -> Int
T -> [T]
T -> T
T -> T -> [T]
T -> T -> T -> [T]
(T -> T)
-> (T -> T)
-> (Int -> T)
-> (T -> Int)
-> (T -> [T])
-> (T -> T -> [T])
-> (T -> T -> [T])
-> (T -> T -> T -> [T])
-> Enum T
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: T -> T
succ :: T -> T
$cpred :: T -> T
pred :: T -> T
$ctoEnum :: Int -> T
toEnum :: Int -> T
$cfromEnum :: T -> Int
fromEnum :: T -> Int
$cenumFrom :: T -> [T]
enumFrom :: T -> [T]
$cenumFromThen :: T -> T -> [T]
enumFromThen :: T -> T -> [T]
$cenumFromTo :: T -> T -> [T]
enumFromTo :: T -> T -> [T]
$cenumFromThenTo :: T -> T -> T -> [T]
enumFromThenTo :: T -> T -> T -> [T]
Enum, Ord T
Ord T =>
((T, T) -> [T])
-> ((T, T) -> T -> Int)
-> ((T, T) -> T -> Int)
-> ((T, T) -> T -> Bool)
-> ((T, T) -> Int)
-> ((T, T) -> Int)
-> Ix T
(T, T) -> Int
(T, T) -> [T]
(T, T) -> T -> Bool
(T, T) -> T -> Int
forall a.
Ord a =>
((a, a) -> [a])
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Int)
-> ((a, a) -> a -> Bool)
-> ((a, a) -> Int)
-> ((a, a) -> Int)
-> Ix a
$crange :: (T, T) -> [T]
range :: (T, T) -> [T]
$cindex :: (T, T) -> T -> Int
index :: (T, T) -> T -> Int
$cunsafeIndex :: (T, T) -> T -> Int
unsafeIndex :: (T, T) -> T -> Int
$cinRange :: (T, T) -> T -> Bool
inRange :: (T, T) -> T -> Bool
$crangeSize :: (T, T) -> Int
rangeSize :: (T, T) -> Int
$cunsafeRangeSize :: (T, T) -> Int
unsafeRangeSize :: (T, T) -> Int
Ix)


-- * serialization

get :: Parser.C parser => Int -> Parser.Fragile parser T
get :: forall (parser :: * -> *). C parser => Int -> Fragile parser T
get Int
code =
   case Int
code of
      Int
0xF8 -> T -> Fragile parser T
forall a. a -> ExceptionalT String parser a
forall (m :: * -> *) a. Monad m => a -> m a
return T
TimingClock
      Int
0xFA -> T -> Fragile parser T
forall a. a -> ExceptionalT String parser a
forall (m :: * -> *) a. Monad m => a -> m a
return T
Start
      Int
0xFB -> T -> Fragile parser T
forall a. a -> ExceptionalT String parser a
forall (m :: * -> *) a. Monad m => a -> m a
return T
Continue
      Int
0xFC -> T -> Fragile parser T
forall a. a -> ExceptionalT String parser a
forall (m :: * -> *) a. Monad m => a -> m a
return T
Stop
      Int
0xFE -> T -> Fragile parser T
forall a. a -> ExceptionalT String parser a
forall (m :: * -> *) a. Monad m => a -> m a
return T
ActiveSensing
      Int
0xFF -> T -> Fragile parser T
forall a. a -> ExceptionalT String parser a
forall (m :: * -> *) a. Monad m => a -> m a
return T
Reset
      Int
_    -> String -> Fragile parser T
forall (m :: * -> *) a. Monad m => String -> T m a
Parser.giveUp (String
"unknown System Real Time message code " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
code)

put :: Writer.C writer => T -> writer
put :: forall writer. C writer => T -> writer
put T
msg =
   case T
msg of
      T
TimingClock   -> Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
0xF8
      T
Start         -> Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
0xFA
      T
Continue      -> Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
0xFB
      T
Stop          -> Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
0xFC
      T
ActiveSensing -> Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
0xFE
      T
Reset         -> Word8 -> writer
forall m. C m => Word8 -> m
Writer.putByte Word8
0xFF