{-# LINE 1 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}
module Sound.ALSA.Sequencer.Marshal.Address where




import qualified Sound.ALSA.Sequencer.Marshal.Client as Client
import qualified Sound.ALSA.Sequencer.Marshal.Port as Port

import qualified Sound.ALSA.Sequencer.Utility as U

import qualified Foreign.C.Types as C
import Foreign.Storable
          (Storable, sizeOf, alignment, peek, poke, pokeByteOff, peekByteOff, )


data T = Cons
   { T -> T
client :: !Client.T
   , T -> T
port   :: !Port.T
   } deriving (T -> T -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: T -> T -> Bool
$c/= :: T -> T -> Bool
== :: T -> T -> Bool
$c== :: T -> T -> Bool
Eq, Eq 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
min :: T -> T -> T
$cmin :: T -> T -> T
max :: T -> T -> T
$cmax :: T -> T -> T
>= :: T -> T -> Bool
$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
compare :: T -> T -> Ordering
$ccompare :: T -> T -> Ordering
Ord)

instance Show T where
   showsPrec :: Int -> T -> ShowS
showsPrec Int
prec (Cons T
c T
p) =
      Int -> String -> [ShowS] -> ShowS
U.showsRecord Int
prec String
"Address" [forall a. Show a => a -> ShowS
U.showsField T
c, forall a. Show a => a -> ShowS
U.showsField T
p]


exp :: T -> (C.CInt,C.CInt)
exp :: T -> (CInt, CInt)
exp T
a = (T -> CInt
Client.exp (T -> T
client T
a), T -> CInt
Port.exp (T -> T
port T
a))


instance Storable T where
  sizeOf :: T -> Int
sizeOf T
_    = (Int
2)
{-# LINE 32 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}
  alignment _ = 1
{-# LINE 33 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}
  peek p      = do cl <- (\hsc_ptr -> peekByteOff hsc_ptr 0) p
{-# LINE 34 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}
                   po <- (\hsc_ptr -> peekByteOff hsc_ptr 1) p
{-# LINE 35 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}
                   return Cons { client = cl, port = po }
  poke :: Ptr T -> T -> IO ()
poke Ptr T
p T
v    = (\Ptr T
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr T
hsc_ptr Int
0) Ptr T
p (T -> T
client T
v)
{-# LINE 37 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}
             forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (\Ptr T
hsc_ptr -> forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr T
hsc_ptr Int
1)   Ptr T
p (T -> T
port T
v)
{-# LINE 38 "src/Sound/ALSA/Sequencer/Marshal/Address.hsc" #-}


unknown :: T
unknown :: T
unknown =
   Cons {
      client :: T
client = T
Client.unknown,
      port :: T
port   = T
Port.unknown
   }

-- | The address of all subscribed ports.
subscribers :: T
subscribers :: T
subscribers =
   Cons {
      client :: T
client = T
Client.subscribers,
      port :: T
port   = T
Port.unknown
   }

broadcast :: T
broadcast :: T
broadcast =
   Cons {
      client :: T
client = T
Client.broadcast,
      port :: T
port   = T
Port.unknown
   }

systemTimer :: T
systemTimer :: T
systemTimer =
   Cons {
      client :: T
client = T
Client.system,
      port :: T
port   = T
Port.systemTimer
   }

systemAnnounce :: T
systemAnnounce :: T
systemAnnounce =
   Cons {
      client :: T
client = T
Client.system,
      port :: T
port   = T
Port.systemAnnounce
   }