{-# 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 :: Availability m b -> DB m (Availability m b)
mkAvailable (AvailableOnDemand DB m b
query) = b -> Availability m b
forall (m :: * -> *) b. b -> Availability m b
Available (b -> Availability m b) -> DB m b -> DB m (Availability m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DB m b
query
mkAvailable (Available b
x)             = Availability m b -> DB m (Availability m b)
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> Availability m b
forall (m :: * -> *) b. b -> Availability m b
Available b
x)

mkTransientlyAvailable :: (Monad m) => Availability m b -> DB m b
mkTransientlyAvailable :: Availability m b -> DB m b
mkTransientlyAvailable (Available b
x)             = b -> DB m b
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 :: AvailabilityList m b -> DB m (AvailabilityList m b)
mkAvailableList (AvailableList (Int
nr, [b]
xs) AvailabilityListWhere -> ConduitT () b (DB m) ()
src)       = AvailabilityList m b -> DB m (AvailabilityList m b)
forall (m :: * -> *) a. Monad m => a -> m a
return (AvailabilityList m b -> DB m (AvailabilityList m b))
-> AvailabilityList m b -> DB m (AvailabilityList m b)
forall a b. (a -> b) -> a -> b
$ (Int, [b])
-> (AvailabilityListWhere -> ConduitT () b (DB m) ())
-> AvailabilityList m b
forall (m :: * -> *) b.
(Int, [b])
-> (AvailabilityListWhere -> ConduitT () b (DB m) ())
-> AvailabilityList m b
AvailableList (Int
nr, [b]
xs) AvailabilityListWhere -> ConduitT () b (DB m) ()
src
mkAvailableList (AvailableListOnDemand (Int
_, AvailabilityListWhere -> ConduitT () b (DB m) ()
query)) = (\[b]
xs -> (Int, [b])
-> (AvailabilityListWhere -> ConduitT () b (DB m) ())
-> AvailabilityList m b
forall (m :: * -> *) b.
(Int, [b])
-> (AvailabilityListWhere -> ConduitT () b (DB m) ())
-> AvailabilityList m b
AvailableList ([b] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [b]
xs, [b]
xs) AvailabilityListWhere -> ConduitT () b (DB m) ()
query) ([b] -> AvailabilityList m b)
-> DB m [b] -> DB m (AvailabilityList m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ConduitT () Void (DB m) [b] -> DB m [b]
forall (m :: * -> *) r. Monad m => ConduitT () Void m r -> m r
C.runConduit (AvailabilityListWhere -> ConduitT () b (DB m) ()
query AvailabilityListWhere
GetAll ConduitT () b (DB m) ()
-> ConduitM b Void (DB m) [b] -> ConduitT () Void (DB m) [b]
forall (m :: * -> *) a b c r.
Monad m =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
C..| ConduitM b Void (DB m) [b]
forall (m :: * -> *) a o. Monad m => ConduitT a o m [a]
CL.consume)

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

lengthAvailabilityList :: AvailabilityList m b -> Int
lengthAvailabilityList :: 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 :: AvailabilityList m a -> ConduitT () a (DB m) ()
srcAvailableList (AvailableList (Int
_, [a]
xs) AvailabilityListWhere -> ConduitT () a (DB m) ()
_)       = [a] -> 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 :: 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'