The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.
getCachePath() asserts that the user has write
permissions to the cache path. If not, an error is produced. Previously,
this check was only done when the cache folder did not exist and had to
be created. Now it also checked pre-existing folders. For performance
reasons, this check is only done once per R session.memoizeCall() would not always find previously cached
results, because R’s just-in-time (JIT) compiler could cause the
internal state of the memomized function to change. Thanks to Tomas
Kalibera for reporting on this and proposing the fix (already back in
2017).The location of the root cache folder as introduced in
R.cache 0.14.0 has been updated to match that of
tools::R_user_dir(), which was introduced in R 4.0.0. On
Linux, this was already the case in R.cache 0.14.0,
whereas on macOS and MS Windows, the folder locations have changed
slightly. If an old cache folder location is detected, then the user
will be queried what action to take, i.e. abort, ignore the old folder,
remove the old folder, or move the old folder to the new location. In
non-interactive mode, the default action is always to ignore.
The package will no longer ask for permission to create the cache
folder as long as the cache folder is compatible with
tools::R_user_dir().
~/.Rcache. On Unix,
the ‘XDG Base Directory Specification’ is followed, which means that the
R.cache folder will typically be
~/.cache/R/R.cache/. On macOS, it will be
~/Library/Caches/R/R.cache/. On modern versions of
Microsoft Windows, environment variables such as
LOCALAPPDATA will be used, which typically resolves to
%USERPROFILE%/AppData/Local,
e.g. C:/Users/alice/AppData/Local. If
R.cache fails to find a proper OS-specific cache
folder, it will fall back to using ~/.Rcache as previously
done. Importantly, if ~/.Rcache already exists, then that
will be used by default. This is done in order to not lose previously
cached files. Users with an existing folder who wish to move to the new
standard need to move or remove the ~/.Rcache folder
manually.Add generateCache() to generate cache pathnames from
a key without creating the cache file. This function was previously not
exported.
Option R.cache.rootPath now defaults to environment
variable R_CACHE_ROOTPATH if it is set.
evalWithMemoization() gained argument
drop to specify which attributes to drop from the
expression object. The default is to now drop any source-reference
attributes.
evalWithMemoization(expr) failed to memoize in
knitr documents because although the same
expr was specified they differed internally due to
source-reference attributes.
evalWithMemoization() used partial dollar name
matching in one place.
R.cache::rootPath,
R.cache::touchOnLoad, and R.cache::compress
are now defunct. Likewise, environment variable
R_CACHE_PATH and argument onError="print" for
loadCache() are now defunct.R CMD check, unless one is explicitly set via an option
or an environment variable.Now package gives a more informative error message in the rare cases it fails to create the cache root directory or fails to save a cache file.
Updated loadCache() to recognize new file-format
version 3 coming to R.
Added options R.cache.enabled, which defaults to
TRUE, for controlling whether loadCache() and
saveCache() should read/write from cache or not. This
provides an easy mechanism for temporarily disabling
R.cache.
Harmonized R.cache options to all have names
prefixed with R.cache..
clearCache() now prompts the user via
readline(), which is always visible, i.e. it can neither be
captured nor sinked.
Using onError = "print" for loadCache()
is deprecated and replaced by new
onError = "message".
Deprecated R.cache options
R.cache::rootPath, R.cache::touchOnLoad, and
R.cache::compress. Use R.cache.rootPath,
R.cache.touchOnLoad, and R.cache.compress
instead.
Now all prompt and verbose messages are send to the standard error (instead of the standard output).
SPEEDUP: Now memoizedCall() generates cache pathname
only once.
verbose from
memoizedCall().memoizeCall() and
addMemoization().addMemoization() will no longer memoize an already
memoized function.::.generateCache() with
key = NULL would give a hard-to-understand error message.
Now it’s more informative.Added arguments path and rootPath to
getCachePath().
Added argument pathname to
saveCache().
~/.Rcache/, which in turn could cause that
path to be create without asking the user. For instance,
R.cache::loadCache(list()) would do. Thanks to Kurt Hornik
at Vienna University of Economics and Business for reporting on
this.Authors field matches
Authors@R.R.cache Package object is also
available when the package is only loaded (but not attached).Now only importing a minimal set of functions needed from the R.oo and the R.utils packages.
Bumped package dependencies.
clearCache() is exported (re-exported from
R.oo).R.cache:::.assertDigest() called from within another
package would give an error that packageVersion() of
utils was not found.getChecksum() passes ... to
digest(), e.g. argument algo.loadCache() - replaced an
rm() call with NULL assignment.CRAN POLICY: Now all Rd \usage{} lines are at most
90 characters long.
Bumped package dependencies.
startupMessage() of
R.oo.clearCache(..., recursive = TRUE).clearCache() would give error “object ‘dirs’ not
found”.Package now only imports R.methodsS3 and R.oo, no long depends (attaches) them. It still needs to load R.utils.
Now package exports a smaller set of the methods.
ROBUSTNESS: Now package declares S3 methods in the namespace.
Added internal .assertDigest(), which originates
from aroma.core.
... to
NextMethod(), cf. R-devel thread ‘Do not pass’…’
to NextMethod() - it’ll do it for you; missing documentation, a bug or
just me?’ on Oct 16, 2012..Rcache/ directory to
_Rcache/ to avoid R CMD check NOTEs..Internal() for
loading saved data. This could be done in a backward-compatible way
using readRDS()..Internal()
function..Rcache
directory.~/.Rcache/.
However, if it does not exists, then it is created when the package is
loaded, but only after approval by the user (via a textual prompt). If
not approved, or it is not possible to prompt the user (e.g. in a
non-interactive session), then a session-specific temporary directory is
used.getCachePath() and setCacheRootPath()
add a README.txt file to the root path, iff missing. It explains why the
directory structure exists, what created it, and that it is safe to
delete.readCacheHeader() iff running R v2.12.2 or before. Thanks
to Uwe Ligges (R core) for reporting on this.Added support for saving and loading compressed cache files.
Now package uses packageStartupMessage() instead of
cat().
findCache() asserts that any identified
cache file is really a file.dirs (in methods using it)
specifies the subdirectory of the cache root directory.prompt for clearCache()
defaults to TRUE iff interactive() is TRUE, otherwise
FALSE.clearCache().Now generateCache() utilizes a generic function
getChecksum() to obtain the checksum. This makes it
possible to customize how checksums are calculated for different classes
of objects.
Added a default getChecksum() which utilizes
digest::digest().
Added getChecksum() for the Object,
which first clears the cache of the object and the calls the default
ditto.
Added trial version of
evalWithMemoization().
clearCache() would also report on subdirectories.memoizedCall() and
addMemoization().loadFromConn() does not exists.onError to loadCache(), to
specify the action when an error occurs. The default used to be to print
the error message (onError = "print"), but now it generates
a warning ("warning"). The other alternatives are do
silently ignore it, or to throw the error ("error"). Except
for onError = "error", loadCache() always
returns NULL if an error occurs.readCacheHeader() reports the “pathname” in
error/warnings messages, if argument file refers to a file
and the “description” if it refers to a connection.ROBUSTNESS: Added sanity check to readCacheHeader()
testing that the read header identifier is non-empty. This results in a
clearer error message that before.
Renamed the HISTORY file to NEWS.
Added option to updated the “last-modified” timestamp of cache
files whenever they are loaded via loadCache(). This will
help identified what cache files have not been used for a long time. To
turn this on, use
options("R.cache::touchOnLoad" = TRUE).
Now error messages specifies the pathname, if available.
throw() for invalid identifiers was trying to put
the connection object in the output and not the identifier.R CMD check on R v2.6.0 devel. Minor
mods.getCacheRootPath() to the help index page.R CMD check on R v2.5.0.getCacheRootPath() and
setCacheRootPath() to specify where the root of the file
path is located.Now saveCache() and loadCache() takes
optional argument dirs for caching data to subdirectories
of the root cache directory.
Added setCacheRootPath() to set the root cache
directory.
pathname to loadCache() in
order to load “unknown” cache files for which the key is unknown.base::save(), which otherwise includes all of the
surrounding environment if ‘sources’ is not evaluated/missing. For more
details see code and my email to r-devel on 2006-05-25. Thanks to Brian
Ripley for explaining what was going on.Added readCacheHeader().
Added detection of file format version.
Using a special binary file format now. It allows you to check if cache is up-to-date to a source file. If not, the rest of the cache binary file is not loaded.
Added loadCache() and saveCache()
methods.
Created.
These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.