{-# LANGUAGE BangPatterns              #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GADTs                     #-}

module Experimenter.Availability.Ops where

import           Experimenter.Availability.Type

import           Conduit                        as C
import           Data.Conduit.List              as CL

import           Experimenter.DB

mkAvailable :: (Monad m) => Availability m b -> DB m (Availability m b)
mkAvailable :: forall (m :: * -> *) b.
Monad m =>
Availability m b -> DB m (Availability m b)
mkAvailable (AvailableOnDemand DB m b
query) = forall (m :: * -> *) b. b -> Availability m b
Available forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DB m b
query
mkAvailable (Available b
x)             = forall (m :: * -> *) a. Monad m => a -> m a
return (forall (m :: * -> *) b. b -> Availability m b
Available b
x)

mkTransientlyAvailable :: (Monad m) => Availability m b -> DB m b
mkTransientlyAvailable :: forall (m :: * -> *) b. Monad m => Availability m b -> DB m b
mkTransientlyAvailable (Available b
x)             = forall (m :: * -> *) a. Monad m => a -> m a
return b
x
mkTransientlyAvailable (AvailableOnDemand DB m b
query) = DB m b
query

mkAvailableList :: (Monad m) => AvailabilityList m b -> DB m (AvailabilityList m b)
mkAvailableList :: forall (m :: * -> *) b.
Monad m =>
AvailabilityList m b -> DB m (AvailabilityList m b)
mkAvailableList (AvailableList (Int
nr, [b]
xs) AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
src)       = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) b.
(Int, [b])
-> (AvailabilityListWhere -> ConduitT () b (DB m) ())
-> AvailabilityList m b
AvailableList (Int
nr, [b]
xs) AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
src
mkAvailableList (AvailableListOnDemand (Int
_, AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
query)) = (\[b]
xs -> forall (m :: * -> *) b.
(Int, [b])
-> (AvailabilityListWhere -> ConduitT () b (DB m) ())
-> AvailabilityList m b
AvailableList (forall (t :: * -> *) a. Foldable t => t a -> Int
length [b]
xs, [b]
xs) AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
query) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) r. Monad m => ConduitT () Void m r -> m r
C.runConduit (AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
query AvailabilityListWhere
GetAll forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
C..| forall (m :: * -> *) a o. Monad m => ConduitT a o m [a]
CL.consume)

mkTransientlyAvailableList :: (Monad m) => AvailabilityList m b -> DB m [b]
mkTransientlyAvailableList :: forall (m :: * -> *) b. Monad m => AvailabilityList m b -> DB m [b]
mkTransientlyAvailableList (AvailableList (Int
_,[b]
x) AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
_)             = forall (m :: * -> *) a. Monad m => a -> m a
return [b]
x
mkTransientlyAvailableList (AvailableListOnDemand (Int
_,AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
query)) = forall (m :: * -> *) r. Monad m => ConduitT () Void m r -> m r
C.runConduit forall a b. (a -> b) -> a -> b
$ AvailabilityListWhere
-> ConduitT () b (ReaderT SqlBackend (LoggingT (ResourceT m))) ()
query AvailabilityListWhere
GetAll forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
C..| forall (m :: * -> *) a o. Monad m => ConduitT a o m [a]
CL.consume

lengthAvailabilityList :: AvailabilityList m b -> Int
lengthAvailabilityList :: forall (m :: * -> *) b. AvailabilityList m b -> Int
lengthAvailabilityList (AvailableList (Int
nr, [b]
_) AvailabilityListWhere -> ConduitT () b (DB m) ()
_)       = Int
nr
lengthAvailabilityList (AvailableListOnDemand (Int
nr, AvailabilityListWhere -> ConduitT () b (DB m) ()
_)) = Int
nr

srcAvailableList :: (Monad m) => AvailabilityList m a -> ConduitT () a (DB m) ()
srcAvailableList :: forall (m :: * -> *) a.
Monad m =>
AvailabilityList m a -> ConduitT () a (DB m) ()
srcAvailableList (AvailableList (Int
_, [a]
xs) AvailabilityListWhere -> ConduitT () a (DB m) ()
_)       = forall (m :: * -> *) a i. Monad m => [a] -> ConduitT i a m ()
CL.sourceList [a]
xs
srcAvailableList (AvailableListOnDemand (Int
_,AvailabilityListWhere -> ConduitT () a (DB m) ()
src)) = AvailabilityListWhere -> ConduitT () a (DB m) ()
src AvailabilityListWhere
GetAll

srcAvailableListWhere :: AvailabilityListWhere -> AvailabilityList m a -> ConduitT () a (DB m) ()
srcAvailableListWhere :: forall (m :: * -> *) a.
AvailabilityListWhere
-> AvailabilityList m a -> ConduitT () a (DB m) ()
srcAvailableListWhere AvailabilityListWhere
where' (AvailableList (Int, [a])
_ AvailabilityListWhere -> ConduitT () a (DB m) ()
src)           = AvailabilityListWhere -> ConduitT () a (DB m) ()
src AvailabilityListWhere
where'
srcAvailableListWhere AvailabilityListWhere
where' (AvailableListOnDemand (Int
_,AvailabilityListWhere -> ConduitT () a (DB m) ()
src)) = AvailabilityListWhere -> ConduitT () a (DB m) ()
src AvailabilityListWhere
where'