module Sound.ALSA.Sequencer.Event.Accessor (
   highPriority,
   tag,
   queue,
   time,
   timeStamp,
   source,
   dest,
   connect,
   body,
   ) where

import qualified Sound.ALSA.Sequencer.Connect as Connect
import qualified Sound.ALSA.Sequencer.Address as Addr
import qualified Sound.ALSA.Sequencer.Queue as Queue
import qualified Sound.ALSA.Sequencer.Marshal.Time as Time
import qualified Sound.ALSA.Sequencer.Marshal.Event as Event

import qualified Data.Accessor.Basic as Acc


highPriority :: Acc.T Event.T Bool
tag :: Acc.T Event.T Event.Tag
queue :: Acc.T Event.T Queue.T
time :: Acc.T Event.T Time.T
timeStamp :: Acc.T Event.T Time.Stamp
source :: Acc.T Event.T Addr.T
dest :: Acc.T Event.T Addr.T
connect :: Acc.T Event.T Connect.T
body :: Acc.T Event.T Event.Data

highPriority :: T T Bool
highPriority =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\Bool
x T
ev -> T
ev{highPriority :: Bool
Event.highPriority = Bool
x}) T -> Bool
Event.highPriority
tag :: T T Tag
tag =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\Tag
x T
ev -> T
ev{tag :: Tag
Event.tag = Tag
x}) T -> Tag
Event.tag
queue :: T T T
queue =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\T
x T
ev -> T
ev{queue :: T
Event.queue = T
x}) T -> T
Event.queue
time :: T T T
time =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\T
x T
ev -> T
ev{time :: T
Event.time = T
x}) T -> T
Event.time
timeStamp :: T T Stamp
timeStamp = T T T
time forall a b c. T a b -> T b c -> T a c
Acc..> T T Stamp
Time.stampAcc
source :: T T T
source =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\T
x T
ev -> T
ev{source :: T
Event.source = T
x}) T -> T
Event.source
dest :: T T T
dest =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\T
x T
ev -> T
ev{dest :: T
Event.dest = T
x}) T -> T
Event.dest
connect :: T T T
connect =
   forall b a. (b -> a) -> (a -> b) -> T a b
Acc.fromWrapper
      (\(Connect.Cons T
src T
dst) -> (T
src, T
dst))
      (forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T -> T -> T
Connect.Cons)
   forall b c a. T b c -> T a b -> T a c
Acc.<.
   forall a b c. T a b -> T a c -> T a (b, c)
Acc.merge T T T
source T T T
dest
body :: T T Data
body =
   forall a r. (a -> r -> r) -> (r -> a) -> T r a
Acc.fromSetGet (\Data
x T
ev -> T
ev{body :: Data
Event.body = Data
x}) T -> Data
Event.body