- Default persistence in files (both strict file reads and fail safe reads/writes are needed, because reads and writes can collide).
- Direct handling of TVars with full atomic semantic without loosing transparent persistence (getTVars)
- No repeated hashtable lookups in case of atomic rollbacks
- readFileStrict - to be used for instantiate custom persistence in files.
- Not only addings but also deletes of objects within single atomic operations. (withResourcesID)
Also, a minimal description of existing primitives has been added.
This is the header:
|module TCache (|
IResource(..) -- class interface to be instantiated by the user
,DefaultPersistResource(..) --instance of IResource with default definitions, except defkeyResource
,Serializable(..) --instances of DefaultPersistResource must be instances of Serializable as well
,Operation (Insert,Delete) -- data definition used to communicate object Inserts and Deletes to the cache
,Cache -- :: IORef (Ht a,Int, Integer) --The cache definition
,withResourcesID -- :: (IResource a)=> [a]-> --list of resources to be extracted for the user function
-- ([Maybe a]->[Operation a]) --user function that get the retrieved resources
-- ->IO () --and return a list of objects to be inserted/modified or deleted
,withResources -- :: (IResource a)=> [a] --list of resources to be retrieve
-- ->([Maybe a]->[a]) ----function that get the retrieved resources
-- ->IO () --and return a list of objects to be inserted/modified
,withResource -- :: (IResource a)=> a --same as withResources , but for one only object
-- ->([Maybe a]->a) --
-- ->IO () --
,insertResources -- :: (IResource a)=> [a] ->IO () -- create resources in the cache. if there are resources with
-- the same key, they will be updated.
-- getMVars give the transactional variables (TVar´s) to be handled directly by the user. This allows the full
-- semantics of "atomic" blocks. Because the TVars are referenced also by the hashtable, the resources inside these TVars
-- are saved to disk,transparently for the user, on every sync. Also, they are not deleted from the cache until released.
-- getMVars put a high value in the access time an modif. time to avoid the swap process to delete from memory
-- getMVars is also useful when the same resources are frequently accessed. This avoid frequent hashtable lookups.
,getTVars -- :: (IResource a)=> [a] -- the list of resources to be retrieved
-- -> IO [Maybe (TVar a)] -- The Transactional variables (See Data.TVar documentation)
-- releaseMVars allows the release of the resources taken by takeMVars so that them can be swapped to disk if needed.
,releaseTVars -- :: (IResource a)=> [a]-> IO()
,getResources -- :: (IResource a)=>[a] --resources [a] are read from cache and returned
-- -> IO [Maybe a]
,getResource -- :: :: (IResource a)=>a --to retrieve one object instead of a list
-- -> IO [Maybe a]
,deleteResources -- :: (IResource a)=>[a]-> IO() -- delete the list of resources from cache and from persistent storage
,deleteResource -- :: (IResource a)=>a-> IO() -- delete the resource from cache and from persistent storage
,refcache -- :: Cache a --the reference to the cache (see data definition below)
,syncCache -- :: (IResource a) =>Cache a -> IO() --force the atomic write of all the cache objects into permanent storage
--useful for termination
--start the thread that clean and writes on the persistent storage trough syncCache
,clearSyncCacheProc -- :: (IResource a) =>Cache a --The cache reference
-- -> Int --number of seconds betwen checks
-- -> (Integer->Integer-> Bool) --The user-defined check-for-cleanup-from-cache for each object
--(when True, the object is removed from cache)
-- -> Int --The max number of objects in the cache, if more, the cleanup start
-- -> >IO ThreadId --Identifier of the thread created
-- the default check procedure
,defaultCheck -- :: Integer --last access time for a given object
-- ->Integer --last cache syncronization (with the persisten storage)
-- ->Bool --return true for all the elems not accesed since
--half the time between now and the last sync
,readFileStrict -- :: String -> IO String -- Strict file read, needed for persistence trough files