Data.TCache.Defs

some internal definitions. To use default persistence, import Data.TCache.DefaultPersistence instead

Documentation

type AccessTime = Integer

type ModifTime = Integer

data Status a

Constructors

NotRead

DoNotExist

Exist a

data Elem a

Constructors

Elem !a !AccessTime !ModifTime

type TPVar a = TVar (Status (Elem a))

data DBRef a

Constructors

DBRef !String !(TPVar a)

castErr :: (Typeable * a, Typeable * t) => t -> a

class Indexable a where

Indexable is an utility class used to derive instances of IResource

Example:

data Person= Person{ pname :: String, cars :: [DBRef Car]} deriving (Show, Read, Typeable)
data Car= Car{owner :: DBRef Person , cname:: String} deriving (Show, Read, Eq, Typeable)

Since Person and Car are instances of Read ans Show, by defining the Indexable instance will implicitly define the IResource instance for file persistence:

instance Indexable Person where  key Person{pname=n} = "Person " ++ n
instance Indexable Car where key Car{cname= n} = "Car " ++ n

Minimal complete definition

key

Methods

key :: a -> String

defPath :: a -> String

Instances

Indexable Int

Methods

key :: Int -> String

defPath :: Int -> String

Indexable Integer

Methods

key :: Integer -> String

defPath :: Integer -> String

Indexable ()

Methods

key :: () -> String

defPath :: () -> String

Indexable String

Methods

key :: String -> String

defPath :: String -> String

class Serializable a where

Serialize is an alternative to the IResource class for defining persistence in TCache. The deserialization must be as lazy as possible. serialization/deserialization are not performance critical in TCache

Read, Show, instances are implicit instances of Serializable

   serialize  = pack . show
   deserialize= read . unpack

Since write and read to disk of to/from the cache are not be very frequent The performance of serialization is not critical.

Minimal complete definition

serialize

Methods

serialize :: a -> ByteString

deserialize :: ByteString -> a

deserialKey :: String -> ByteString -> a

setPersist :: a -> Maybe Persist

class PersistIndex a where

Used by IndexQuery for index persistence(see Data.TCache.IndexQuery.

Minimal complete definition

persistIndex

Methods

persistIndex :: a -> Maybe Persist

type Key = String

data Persist

a persist mechanism has to implement these three primitives filePersist is the default file persistence

Constructors

Persist

delete

Fields

• readByKey :: Key -> IO (Maybe ByteString)

  read by key. It must be strict

• write :: Key -> ByteString -> IO ()

  write. It must be strict

• delete :: Key -> IO ()

filePersist :: Persist

Implements default default-persistence of objects in files with their keys as filenames

defaultPersistIORef :: IORef Persist

setDefaultPersist :: Persist -> IO ()

Set the default persistence mechanism of all serializable objects that have setPersist= const Nothing. By default it is filePersist

this statement must be the first one before any other TCache call

getDefaultPersist :: Persist

getPersist :: (Typeable * a, Serializable a) => a -> Persist

defaultReadByKey :: String -> IO (Maybe ByteString)

defaultWrite :: String -> ByteString -> IO ()

safeWrite :: FilePath -> ByteString -> IO ()

defaultDelete :: String -> IO ()

defReadResourceByKey :: (Typeable * a, Indexable a, Serializable a) => [Char] -> IO (Maybe a)

defWriteResource :: (Typeable * a, Serializable a, Indexable a) => a -> IO ()

defDelResource :: (Serializable a, Typeable * a, Indexable a) => a -> IO ()

readFileStrict :: FilePath -> IO ByteString

Strict read from file, needed for default file persistence