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)

Instances

(IResource a, Typeable a) => Read (DBRef a)

Defined in Data.TCache

Methods

readsPrec :: Int -> ReadS (DBRef a)

readList :: ReadS [DBRef a]

readPrec :: ReadPrec (DBRef a)

readListPrec :: ReadPrec [DBRef a]

Show (DBRef a)

Defined in Data.TCache.Defs

Methods

showsPrec :: Int -> DBRef a -> ShowS

show :: DBRef a -> String

showList :: [DBRef a] -> ShowS

Eq (DBRef a)

Defined in Data.TCache.Defs

Methods

(==) :: DBRef a -> DBRef a -> Bool

(/=) :: DBRef a -> DBRef a -> Bool

Ord (DBRef a)

Defined in Data.TCache.Defs

Methods

compare :: DBRef a -> DBRef a -> Ordering

(<) :: DBRef a -> DBRef a -> Bool

(<=) :: DBRef a -> DBRef a -> Bool

(>) :: DBRef a -> DBRef a -> Bool

(>=) :: DBRef a -> DBRef a -> Bool

max :: DBRef a -> DBRef a -> DBRef a

min :: DBRef a -> DBRef a -> DBRef a

castErr :: (Typeable a1, Typeable a2) => a1 -> a2

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

class PersistIndex a where

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

Methods

persistIndex :: a -> Maybe Persist

Instances

Serializable a => PersistIndex a

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

Defined in Data.TCache.DefaultPersistence

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

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

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 :: (Serializable a, Typeable a) => a -> Persist

defaultReadByKey :: String -> IO (Maybe ByteString)

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

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

defaultDelete :: String -> IO ()

defReadResourceByKey :: (Indexable a, Serializable a, Typeable a) => String -> IO (Maybe a)

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

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

readFileStrict :: FilePath -> IO ByteString

Strict read from file, needed for default file persistence