Data.TCache.DefaultPersistence

This module decouples the 'IResource" class in two classes one for key extraction Indexable and other ('Serializable" for serlalization and persistence .The last one defines persistence in files as default, but it can be changed to persistence in databases, for example.

The definitions of these classes are in Defs.hs

Documentation

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

Arguments

:: a

-> String

additional extension for default file paths. IMPORTANT: defPath must depend on the datatype, not the value (must be constant). Default is ".tcachedata/"

Instances

Indexable String

Defined in Data.TCache.Defs

Methods

key :: String -> String

defPath :: String -> String

Indexable Integer

Defined in Data.TCache.Defs

Methods

key :: Integer -> String

defPath :: Integer -> String

Indexable ()

Defined in Data.TCache.Defs

Methods

key :: () -> String

defPath :: () -> String

Indexable Int

Defined in Data.TCache.Defs

Methods

key :: Int -> String

defPath :: Int -> 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

Arguments

:: a

-> Maybe Persist

defaultPersist if Nothing

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

filePersist :: Persist

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

data Persist

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

Constructors

Persist

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 ()

  delete

Orphan instances

Serializable a => PersistIndex a

By default the index of a Serializable data persist with the data.

Methods

persistIndex :: a -> Maybe Persist

(Typeable a, Indexable a, Serializable a) => IResource a

Methods

keyResource :: a -> String

readResourceByKey :: String -> IO (Maybe a)

readResourcesByKey :: [String] -> IO [Maybe a]

readResource :: a -> IO (Maybe a)

writeResource :: a -> IO ()

writeResources :: [a] -> IO ()

delResource :: a -> IO ()

delResources :: [a] -> IO ()