{-| This module provides a registry for the specific type with the Text key.

This module is intended to be imported @qualified@, like:
@
import qualified Data.Registry as R
@
-}
module Data.Registry (
  module Data.Registry.Class,

  Registry(..),
  fromList,
  new,
) where

import Control.Monad.IO.Class
import qualified Data.Text as T
import Data.Registry.Class
import Data.Registry.HashTable

-- | The @Registry@ type can represents any 'IRegistry' instance.
data Registry v = forall reg. IRegistry reg => Registry (reg v)

instance IRegistry Registry where
  !? :: Registry v -> Text -> m (Maybe v)
(!?) (Registry reg :: reg v
reg) t :: Text
t = reg v -> Text -> m (Maybe v)
forall (reg :: * -> *) (m :: * -> *) v.
(IRegistry reg, MonadIO m) =>
reg v -> Text -> m (Maybe v)
(!?) reg v
reg Text
t
  asVec :: Registry v -> IOVector v
asVec (Registry reg :: reg v
reg) = reg v -> IOVector v
forall (reg :: * -> *) v. IRegistry reg => reg v -> IOVector v
asVec reg v
reg
  write :: Registry v -> Text -> v -> m ()
write (Registry reg :: reg v
reg) k :: Text
k v :: v
v = reg v -> Text -> v -> m ()
forall (reg :: * -> *) (m :: * -> *) v.
(IRegistry reg, MonadIO m) =>
reg v -> Text -> v -> m ()
write reg v
reg Text
k v
v
  register :: Registry v -> Text -> v -> m ()
register (Registry reg :: reg v
reg) k :: Text
k v :: v
v = reg v -> Text -> v -> m ()
forall (reg :: * -> *) (m :: * -> *) v.
(IRegistry reg, MonadIO m) =>
reg v -> Text -> v -> m ()
register reg v
reg Text
k v
v
  insert :: Registry v -> Int -> Text -> v -> m ()
insert (Registry reg :: reg v
reg) i :: Int
i k :: Text
k v :: v
v = reg v -> Int -> Text -> v -> m ()
forall (reg :: * -> *) (m :: * -> *) v.
(IRegistry reg, MonadIO m) =>
reg v -> Int -> Text -> v -> m ()
insert reg v
reg Int
i Text
k v
v
  delete :: Registry v -> Text -> m ()
delete (Registry reg :: reg v
reg) k :: Text
k = reg v -> Text -> m ()
forall (reg :: * -> *) (m :: * -> *) v.
(IRegistry reg, MonadIO m) =>
reg v -> Text -> m ()
delete reg v
reg Text
k

-- | /O(n)/ Create a registry from a list. The current implementation uses a hashtable, defined in the module 'Data.Registry.HashTable'.
fromList :: MonadIO m => [(T.Text, v)] -> m (Registry v)
fromList :: [(Text, v)] -> m (Registry v)
fromList xs :: [(Text, v)]
xs = (HashTableImpl Text v -> Registry v)
-> m (HashTableImpl Text v) -> m (Registry v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap HashTableImpl Text v -> Registry v
forall v (reg :: * -> *). IRegistry reg => reg v -> Registry v
Registry (m (HashTableImpl Text v) -> m (Registry v))
-> m (HashTableImpl Text v) -> m (Registry v)
forall a b. (a -> b) -> a -> b
$ [(Text, v)] -> m (HashTableImpl Text v)
forall (m :: * -> *) v.
MonadIO m =>
[(Text, v)] -> m (HashTableImpl Text v)
fromListImpl [(Text, v)]
xs

-- | Create a new empty registry.
new :: MonadIO m => m (Registry v)
new :: m (Registry v)
new = [(Text, v)] -> m (Registry v)
forall (m :: * -> *) v. MonadIO m => [(Text, v)] -> m (Registry v)
fromList []