Apecs.Stores

Documentation

data Map c

A map from Data.Intmap.Strict. O(n log(n)) for most operations. Yields safe runtime representations of type Maybe c.

Instances

Store (Map c)

Associated Types

type SafeRW (Map c) :: *

type Stores (Map c) :: *

Methods

explGetUnsafe :: Map c -> Int -> IO (Stores (Map c))

explGet :: Map c -> Int -> IO (SafeRW (Map c))

explSet :: Map c -> Int -> Stores (Map c) -> IO ()

explSetMaybe :: Map c -> Int -> SafeRW (Map c) -> IO ()

explModify :: Map c -> Int -> (Stores (Map c) -> Stores (Map c)) -> IO ()

explCmap :: Map c -> (Stores (Map c) -> Stores (Map c)) -> IO ()

explCmapM_ :: MonadIO m => Map c -> (Stores (Map c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Map c -> ((Int, Stores (Map c)) -> m a) -> m ()

explCmapM :: MonadIO m => Map c -> (Stores (Map c) -> m a) -> m [a]

explCimapM :: MonadIO m => Map c -> ((Int, Stores (Map c)) -> m a) -> m [a]

HasMembers (Map c)

Methods

explDestroy :: Map c -> Int -> IO ()

explExists :: Map c -> Int -> IO Bool

explMembers :: Map c -> IO (Vector Int)

explReset :: Map c -> IO ()

explImapM_ :: MonadIO m => Map c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Map c -> (Int -> m a) -> m [a]

Initializable (Map c)

Associated Types

type InitArgs (Map c) :: *

Methods

initStoreWith :: InitArgs (Map c) -> IO (Map c)

type SafeRW (Map c)

type SafeRW (Map c) = Maybe c

type Stores (Map c)

type Stores (Map c) = c

type InitArgs (Map c)

type InitArgs (Map c) = ()

data Set c

A store that keeps membership, but holds no values. Produces flag runtime values.

Instances

Flag c => Store (Set c)

Associated Types

type SafeRW (Set c) :: *

type Stores (Set c) :: *

Methods

explGetUnsafe :: Set c -> Int -> IO (Stores (Set c))

explGet :: Set c -> Int -> IO (SafeRW (Set c))

explSet :: Set c -> Int -> Stores (Set c) -> IO ()

explSetMaybe :: Set c -> Int -> SafeRW (Set c) -> IO ()

explModify :: Set c -> Int -> (Stores (Set c) -> Stores (Set c)) -> IO ()

explCmap :: Set c -> (Stores (Set c) -> Stores (Set c)) -> IO ()

explCmapM_ :: MonadIO m => Set c -> (Stores (Set c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Set c -> ((Int, Stores (Set c)) -> m a) -> m ()

explCmapM :: MonadIO m => Set c -> (Stores (Set c) -> m a) -> m [a]

explCimapM :: MonadIO m => Set c -> ((Int, Stores (Set c)) -> m a) -> m [a]

HasMembers (Set c)

Methods

explDestroy :: Set c -> Int -> IO ()

explExists :: Set c -> Int -> IO Bool

explMembers :: Set c -> IO (Vector Int)

explReset :: Set c -> IO ()

explImapM_ :: MonadIO m => Set c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Set c -> (Int -> m a) -> m [a]

Initializable (Set c)

Associated Types

type InitArgs (Set c) :: *

Methods

initStoreWith :: InitArgs (Set c) -> IO (Set c)

type SafeRW (Set c)

type SafeRW (Set c) = Bool

type Stores (Set c)

type Stores (Set c) = c

type InitArgs (Set c)

type InitArgs (Set c) = ()

class Flag c where

Class for flags, used by Set to yield runtime representations.

Minimal complete definition

flag

Methods

flag :: c

data Cache n s

A cache around another store. The wrapped store must produce safe representations using Maybe. Note that iterating over a cache is linear in its size, so large, sparsely populated caches will actually decrease performance.

Instances

((~) * (SafeRW s) (Maybe (Stores s)), Store s) => Store (Cache n s)

Associated Types

type SafeRW (Cache n s) :: *

type Stores (Cache n s) :: *

Methods

explGetUnsafe :: Cache n s -> Int -> IO (Stores (Cache n s))

explGet :: Cache n s -> Int -> IO (SafeRW (Cache n s))

explSet :: Cache n s -> Int -> Stores (Cache n s) -> IO ()

explSetMaybe :: Cache n s -> Int -> SafeRW (Cache n s) -> IO ()

explModify :: Cache n s -> Int -> (Stores (Cache n s) -> Stores (Cache n s)) -> IO ()

explCmap :: Cache n s -> (Stores (Cache n s) -> Stores (Cache n s)) -> IO ()

explCmapM_ :: MonadIO m => Cache n s -> (Stores (Cache n s) -> m a) -> m ()

explCimapM_ :: MonadIO m => Cache n s -> ((Int, Stores (Cache n s)) -> m a) -> m ()

explCmapM :: MonadIO m => Cache n s -> (Stores (Cache n s) -> m a) -> m [a]

explCimapM :: MonadIO m => Cache n s -> ((Int, Stores (Cache n s)) -> m a) -> m [a]

HasMembers s => HasMembers (Cache n s)

Methods

explDestroy :: Cache n s -> Int -> IO ()

explExists :: Cache n s -> Int -> IO Bool

explMembers :: Cache n s -> IO (Vector Int)

explReset :: Cache n s -> IO ()

explImapM_ :: MonadIO m => Cache n s -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Cache n s -> (Int -> m a) -> m [a]

(KnownNat n, Initializable s) => Initializable (Cache n s)

Associated Types

type InitArgs (Cache n s) :: *

Methods

initStoreWith :: InitArgs (Cache n s) -> IO (Cache n s)

type SafeRW (Cache n s)

type SafeRW (Cache n s) = SafeRW s

type Stores (Cache n s)

type Stores (Cache n s) = Stores s

type InitArgs (Cache n s)

type InitArgs (Cache n s) = InitArgs s

data Global c

Global value. Must be given an initial value upon construction.

Instances

Initializable (Global c)

Associated Types

type InitArgs (Global c) :: *

Methods

initStoreWith :: InitArgs (Global c) -> IO (Global c)

GlobalRW (Global c) c

Methods

explGlobalRead :: Global c -> IO c

explGlobalWrite :: Global c -> c -> IO ()

explGlobalModify :: Global c -> (c -> c) -> IO ()

type InitArgs (Global c)

type InitArgs (Global c) = c

data IndexTable s

A table that keeps a hashtable of indices along with its writes. TODO: Benchmark? hashing function as argument?

Instances

((~) * (SafeRW s) (Maybe (Stores s)), ToIndex (Stores s), Store s) => Store (IndexTable s)

Associated Types

type SafeRW (IndexTable s) :: *

type Stores (IndexTable s) :: *

Methods

explGetUnsafe :: IndexTable s -> Int -> IO (Stores (IndexTable s))

explGet :: IndexTable s -> Int -> IO (SafeRW (IndexTable s))

explSet :: IndexTable s -> Int -> Stores (IndexTable s) -> IO ()

explSetMaybe :: IndexTable s -> Int -> SafeRW (IndexTable s) -> IO ()

explModify :: IndexTable s -> Int -> (Stores (IndexTable s) -> Stores (IndexTable s)) -> IO ()

explCmap :: IndexTable s -> (Stores (IndexTable s) -> Stores (IndexTable s)) -> IO ()

explCmapM_ :: MonadIO m => IndexTable s -> (Stores (IndexTable s) -> m a) -> m ()

explCimapM_ :: MonadIO m => IndexTable s -> ((Int, Stores (IndexTable s)) -> m a) -> m ()

explCmapM :: MonadIO m => IndexTable s -> (Stores (IndexTable s) -> m a) -> m [a]

explCimapM :: MonadIO m => IndexTable s -> ((Int, Stores (IndexTable s)) -> m a) -> m [a]

((~) * (SafeRW s) (Maybe (Stores s)), ToIndex (Stores s), Store s) => HasMembers (IndexTable s)

Methods

explDestroy :: IndexTable s -> Int -> IO ()

explExists :: IndexTable s -> Int -> IO Bool

explMembers :: IndexTable s -> IO (Vector Int)

explReset :: IndexTable s -> IO ()

explImapM_ :: MonadIO m => IndexTable s -> (Int -> m a) -> m ()

explImapM :: MonadIO m => IndexTable s -> (Int -> m a) -> m [a]

(ToIndex (Stores s), Initializable s) => Initializable (IndexTable s)

Associated Types

type InitArgs (IndexTable s) :: *

Methods

initStoreWith :: InitArgs (IndexTable s) -> IO (IndexTable s)

((~) * (Stores s) c, ToIndex (Stores s)) => Query (ByComponent c) (IndexTable s)

Methods

explSlice :: IndexTable s -> ByComponent c -> IO (Vector Int)

((~) * (Stores s) c, ToIndex (Stores s)) => Query (ByIndex c) (IndexTable s)

Methods

explSlice :: IndexTable s -> ByIndex c -> IO (Vector Int)

type SafeRW (IndexTable s)

type SafeRW (IndexTable s) = SafeRW s

type Stores (IndexTable s)

type Stores (IndexTable s) = Stores s

type InitArgs (IndexTable s)

type InitArgs (IndexTable s) = InitArgs s

class Bounded a => ToIndex a where

A component that can be hashed to a table index. minBound must hash to the lowest possible value, maxBound must hash to the highest. For Enums, toIndex = fromEnum

Minimal complete definition

toIndex

Methods

toIndex :: a -> Int

newtype ByIndex a

A query to an IndexTable by an explicit index

Constructors

ByIndex Int

Instances

((~) * (Stores s) c, ToIndex (Stores s)) => Query (ByIndex c) (IndexTable s)

Methods

explSlice :: IndexTable s -> ByIndex c -> IO (Vector Int)

newtype ByComponent c

A query to an IndexTable by a reference component

Constructors

ByComponent c

Instances

((~) * (Stores s) c, ToIndex (Stores s)) => Query (ByComponent c) (IndexTable s)

Methods

explSlice :: IndexTable s -> ByComponent c -> IO (Vector Int)