NEWS.md
getMethods() is an R.oo generic in R (>= 4.5.0), whereas in versions before that it is n methods generic. This is because methods::getMethods() is being deprecated in base R.showNews() for Package recognizes ‘NEWS.md’ files too.$<- and [[<- for Object to the list of S3 methods that tries to ignore objects of class Object that are of the kind that R.oo creates. This fixes conflicts with Object objects that the arrow package produces, which are non-R.oo objects. Other S3 Object methods already do this since R.oo 1.20.0 to workaround similar issues with the rJava package.getDate() for Package returned NA because it was looking for DESCRIPTION field Date, which has been renamed to Date/Publication.throw(), which previously was a re-export of ditto from R.methodsS3. This change prevents the message “Registered S3 method overwritten by ‘R.oo’: … throw.default R.methodsS3” from appearing when the R.oo package is loaded (directly or indirectly).gc() for Object. Use clearCache(..., gc = TRUE).example(getBundle.Package) because they may take more than 5 seconds when run on CRAN where installed.packages() will take a long time due to many thousands of packages.clone() is always created. This avoids the recurring issues where the creation of generic R.oo::clone() was skipped if another clone() generic already existed during package installation from source. This would in turn cause for instance the R.utils package to fail during loading (R.utils Issue #29). Thanks to Matt Dowle for reporting on this and insisting on a fix.Removed previously defunct update() for Package; use update.packages().
Removed previously defunct registerFinalizer() for Object.
Previous deprecated gc() for Object is now defunct; use clearCache(..., gc = TRUE) instead.
Now TAB-completion works on elements of Object, BasicObject, and Class.
Now getElement() works also for Object, Class, and BasicObject.
[[() for Object, Class and BasicObject gained argument exact, but exact = FALSE is currently ignored and treated as exact = TRUE.
Some S3 methods for R.oo classes Object and Exception would interfere with ditto for rJava objects that had class attributes containing "Object" and "Exception". Although these classes have the same name, and therefore are in conflict, they represent completely different classes. For methods where conflicts have been identified, the R.oo implementations will try to detect the conflict and call the next method instead.
Now print() and startupMessage() for Package report on package date only if date exists.
CLEANUP: Explicit namespace imports also from utils package.
CLEANUP: Drop unused code.
clazz[[method]]() for Class object clazz did not call the intended static method, as clazz$<method>() would do.
getClasses() for Package would return NULL.
Now explicitly declare “default” S3 methods for getClasses() and getMethods().
Dropped non-ASCII characters from R source comments.
Now charToInt() returns integers as documented (was numerics).
objectSize() for environment could result in infinite recursive calls if there circular dependencies between environments. Added package test for objectSize() including this case.
getKnownSubclasses() for Class could throw an error if one of the objects “scanned” for being a function and of class Class would thrown an error from just looking at it. See R-devel thread ‘Inspect a “delayed” assigned whose value throws an error?’ on 2015-01-26 for details.
Forgot to explicitly import getClasses() and getMethods() from the methods package. Interestingly, this one has never given an error.
getStaticInstance() for Object now searches the parent/calling environment as well. This covers the case when constructors and objects are created in a local environment (contrary to package namespaces and the global environment).
update() for Package is defunct; use update.packages().decreasing to ll(), e.g. ll(sortBy = "objectSize", decreasing = TRUE).getRdDeclaration(), getRdHierarchy(), and getRdMethods() for Class handles also non-exported methods and classes.Object:s no longer calls finalize() on the Object itself unless the R.oo package is loaded, whereas previously it would have tried to temporarily reattach the R.oo package. On the other hand, it is now sufficient to have R.oo loaded for finalize() to be called, whereas in the passed it also had to be attached.gc() for Object. Use clearCache(..., gc = TRUE) instead.Now static method Class$forName() accepts optional envir argument for specifying from where to search for the Class object.
Added argument ‘gc = FALSE’ to clearCache(). It is recommended to start using clearCache(obj, gc = TRUE) instead of gc(obj).
registerFinalizer() for Object.Object() to specify whether a finalizer should be registered or not. If so, then generic function finalize() is called on the Object. Furthermore, extend() for Object gained argument ...finalize, which, regardless of argument finalize of Object, force the registration of a finalizer (...finalize = TRUE) or the removal of one (...finalize = FALSE). If ...finalize = NA (default), then the finalizer is enabled/disabled according to argument finalize of Object. For backward compatibility reasons, the default behavior is still to register a finalizer for Object:s, but this may change in a future release.Object finalizers will no longer try to re-attach the R.oo package if library() is in the process of trying to attach another package, because otherwise a cyclic loading of namespaces may occur. This was observed for a package that allocated a temporary Object .onAttach() which then was garbage collected and finalized.R CMD INSTALL. This may be because a Package object (R.oo::R.oo) is assigned during the loading of the namespace. Since Package extends() an Object object, this may end up loading R.oo again. To avoid this, R.oo::R.oo is now assigned using delayed assignment.@howToCite does a better job when there are multiple citations in CITATION.getCall() from stats, iff R (>= 2.14.0).Deprecated update() for Package.
Deprecated non-used registerFinalizer() for Object.
R.methodsS3::appendVarArgs().extend() for Object:s assumed that the utils is attached while calling capture.output(), which under certain conditions could generate ‘Error in getObjectInfo(this) : could not find function “capture.output”’ while the garbage collector was running. In extreme cases it could also crash R.library("R.oo", warn.conflicts = FALSE, quietly = TRUE) will load the package completely silently.
Now startupMessage() for Package acknowledges library(..., quietly = TRUE).
setConstructorS3() no longer requires that R.oo is attached (“loaded”).
getHowToCite() for Package utilizes utils::citation(), if package don’t contain a HOWTOCITE file. It is recommended to write packages with CITATION instead of HOWTOCITE.charToInt(), intToChar(), hashCode(), equals(), dimension(), and trim().Made get- and showHowToCite() protected methods.
Dropped deprecated inst/HOWTOSITE replaced by inst/CITATION.
Now it’s possible to call static methods without attaching (“loading”) the package, e.g. R.oo::Class$forName("Object"). Added unit tests for this.
Now getPackage() for Class first searches the namespace of the Class object and then the attached (“loaded”) packages.
Now $ and $<- for Object locates the static instance of the Class using getStaticInstance() for Object.
Updated getStaticInstance() for Object to search more locations.
Now R.oo::ll() works without attaching the package. This is done by attaching R.oo when called.
Now it is possible to use static methods of a Class without attaching the package where the Class is defined, e.g. R.utils::Arguments$getIndex(2). To enable this feature, options("R.oo::Class/searchNamespaces"=TRUE) must be set.
Now Rdoc$compile() infer the package name from the DESCRIPTION file (instead from the package directory name).
Added argument path to compileRdoc().
Added support for Rdoc tag @author to have an optional value, e.g. @author "John Doe" as well as @author "JD, FB" where the initials are inferred from the package’s DESCRIPTION file.
Added compileRdoc() to make it easier to compile Rdoc comments into Rd help files, e.g. Rscript -e "R.oo::compileRdoc()".
Now getAuthor() and getMaintainer() for Package use the Authors@R field of DESCRIPTION and if not found, then the Author/Maintainer fields. In addition, using argument as = "person" will parse and return the results as a person list.
It is now easier to find help for static method, e.g. help("Object$load") and ?"Object$load".
For “static” methods (e.g. Object$load()), the Rdoc compiler now generates a \usage{} section without the deprecated Rd markup \synopsis{}, which has been replaced by the static call placed in a comment. It also uses the static method as the name and alias (e.g. \name{Object$load}).
Object finalizers reentrant. This was previously not the case on R prior to R v2.15.2 Patched r61487 iff the garbage collection is triggered from within base::parse() and the R.oo package is not already loaded when the finalizer is called. In such cases, R could crash. Added a package system test for this. Thanks to Duncan Murdoch (R core) for reporting on this and R core for making base::library() reentrant in R (>= 2.15.2 Patched r61487).format to getInternalAddress() for Object.as.character() for Object would contain the decimal value and not the hexadecimal one.Further preparation for supporting R.oo and its derived packages to be imported without attaching (“loading”) them.
Replaced all data.class(obj) with class(obj)[1L].
getMethods() for Class would give an error if no methods were found for the queried Class.
In the rare case where getStaticInstance() for Class failed to setup a static instance, the temporary state set internally would not be unset.
startupMessage() for Package.R CMD check for R devel no longer gives a NOTE on attach().getKnownSubclasses() for Class a bit faster.Object:s (i.e. excluding those which are of a subclass of Object) will no longer be called if the R.oo package has been detached. This should be a very unlikely scenario.extend() for Object dropped existing field modifiers.getStaticInstance() for Class sets the environment for the returned Object to that of the Class.... 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.GENERALIZATION: Now <Class>$<staticFcn>(...) calls the corresponding generic function <staticFcn>(static, ...), where static is the static object of Class <Class>. This allows for using NextMethod() in static functions. Calls to <Object>$<staticFcn>(...) and <BasicObject>$<staticFcn>(...) were adjusted analogously.
Now throw() for Exception outputs the error message both above and below the stack trace, which is particularly useful when the stack trace is long.
abort() for condition to utilize invokeRestart("abort"). This avoids having to call .Internal(.signalCondition(...)). It also means that the message outputted by abort() no longer starts with a “Error in …:” line. abort() imitates how stop() works, but without the signalling.getContribUrl() and getDevelUrl() would give an error if corresponding fields did not exists in the DESCRIPTION file. Now they return NAs just as getUrl().GENERALIZATION: Added newInstance() for BasicObject.
ROBUSTNESS: Now constructor BasicObject() is guaranteed to return an object with non-duplicated class attribute elements.
Added argument export to setConstructorS3().
Now Rdoc$getUsage() searches also the package namespace for the function/method definition. This is done, before looking in the global search path.
setConstructorS3() no longer sets attribute formals. It has been deprecated since April 2003.cleanup of getStackTrace() for Exception via an option.Made stack traces of Exception:s more informative and cleaner.
Now the default throw() of R.methodsS3 is “quietly” overwritten, i.e. there is no longer a warning about it when R.oo is loaded.
Now package no longer warns about renaming existing functions getMethods() and getClasses() of base to default methods during installation, iff R.methodsS3 (>= 1.2.3).
CRAN POLICY: Replaced all appendVarArgs() for base functions that do .Internal() calls, because they would then appear as local functions of this package and hence not be accepted by CRAN according to their new policies. Instead we now create “default” functions that are wrappers to the corresponding functions in the base package. Extra care has to be taken for functions that have arguments whose values are dependent on the call environment/closure.
CRAN POLICY: Dropped .Internal() calls in the default ll() method, in getMethods() for Class objects, and in throw() for Exception:s.
package.description() from getDescriptionFile() for Package, which was done for compatibility reasons when it was deprecated in R v1.9.0. It will be dropped completely in R v2.15.0.help(setConstructorS3) about the requirement that constructors defined by setConstructorS3() have to be callable without arguments.ROBUSTNESS: Now finalizers for Object:s are registered to be called also when the R session is quit, if the R.oo::Object/finalizeOnExit option is TRUE. If FALSE (default), as before, the finalizers were only executed when Object:s were cleaned up by the garbage collector.
Turned of the default instantiation timestamp for Object and BasicObject. The main reason is that it makes it very complicated to calculate reproducible checksums. However, for backward compatibility, it is possible to turn on the timestamp by setting option R.oo::Object/instantiationTime. For BasicObject there is option R.oo::BasicObject/instantiationTime.
Added protected getFieldModifiers() and getFieldModifier().
Added argument recursive to clearCache() for recursively traversing all elements are clearing the cache of all detected Object:s.
Now clearCache() also calls clearLookupCache().
Added protected clearLookupCache() for clearing internal objects stored in the Object and that are used for faster field lookups.
getInstanciationTime().addTimestamp of Rdoc$compile() defaults to FALSE. This way the generate Rd file will remain identical unless there are real Rdoc/code changes. Not adding timestamps is better when working with a version control systems.check() of Rdoc would throw the error “object ‘res’ not found”.help(R.oo).isOlderThan() for Package.save() of Object to leave an incomplete file due to say power failures etc. This is done by first writing to a temporary file, which is then renamed. If the temporary file already exists, an exception is thrown.print() statement in attachLocally() for Object:s.objectSize() for environments.getBundle() of Package gave “Error in getBundle.Package(pkg) : subscript out of bounds” starting with R v2.10.0.registerFinalizer() for Object.intToChar() and charToInt() where mixed up. Thanks to Jens Philip Hoehmann for reporting this.a %in% b with is.element(a,b) due to an old and weird bug that I cannot reproduce, cf. my R-devel post in thread ‘Argument “nomatch” matched by multiple actual arguments … %in% -> match?!?’ on March 6, 2008. Thanks Ran Pang for reminding me and for additional troubleshooting.getInstantiationTime(), but keeping misspelled (and now deprecated) getInstanciationTime() for backward compatibility. The internal attribute was also renamed, but the above method look for both in case saved objects are loaded.Added getNews() and showNews() to the Package class. NEWS files are now detected (first).
Added getConstructorS3().
The NEWS file does now replace the former HISTORY file of R.oo.
If running R v2.7.0 or new, the first element of vector ASCII is an empty string. This is because ASCII 0x00 cannot be represented as an R string and in R v2.8.0 it will give a warning. Note though that regardless of this, charToInt(intToChar(0)) == 0 is still TRUE.
getName() for environment:s.getInternalAddress() would return NA.a-Z is illegal on (at least) some locale, e.g. ‘C’ (where A-z works). The only way to specify the ASCII alphabet is to list all characters explicitly, which we now do in all methods of the package. See the r-devel thread “invalid regular expression ‘[a-Z]’” on 2008-03-05 for details.finalize() more error prone.setMethodS3() and related methods from R.oo and put them in a standalone R.methodsS3 package. While doing this, the enforceRCC argument used by setMethodS3() was renamed to validators which now takes an optional list of functions. Any code using argument enforceRCC = FALSE must now use validators = NULL.packageStartupMessage() so that it can be suppressed.Removed showAndWait() for simpleError, which displayed a TclTk dialog for a generic error. Never used. If someone wants the code, please tell me and I’ll forward it.
Removed deprecated trycatch(); use tryCatch() instead.
Object:s are garbage collected after R.oo has been detached, the error ‘Error in function (env) : could not find function “finalize”’ would be thrown, because the registered finalizer hook tries to call the generic function finalize() in R.oo. We solve this by trying to reload R.oo (and the unload it again). Special care was taken so that Object:s allocated by R.oo itself won’t cause an endless loop.list from all substitute() calls.getData() because there might be a name clash with the nlme package.error instead of ex in the exception handling of update() of the Package class.Now ll() uses objectSize() instead of object.size(). It also returns the properties in its “minimal” data type, e.g. the objectSize column contains integers (not characters as before). This makes it possible to utilize subset() on the ll() output.
Added a default method for objectSize(), which is just a wrapper for object.size().
trycatch() defunct, i.e. it gives an error suggesting to use tryCatch() instead.getMethods(..., private = FALSE) for class Class would return private methods, and private = TRUE would remove them. It should be the other way around.
getMethods() for Class would sometimes give error message: “Error in result[[k]] : subscript out of bounds”. This in turn would cause Rdoc to fail.
getInternalAddress() coerced the address to an integer, addresses about 2^32 bytes = 4 GiB got address NA. Now getInternalAddress() and the default hashCode() return a double.Object class. Currently it is only the “cached” modifier that is recognized. To specify that a field, say, foo is “cached”, list it as cached:foo. Fields that are “cached” will be assigned to NULL when clearCache() of the object is called. For convenience there is also a gc() method for all Object:s. See ?gc.Object for an example.Added method getEnvironment() to class Object, which will return the environment where the Object’s members are stored.
Now ll() does not assign variables in the lookup environment, which means it will work with sealed environments too.
Added isBeingCreated() to Class in order to check if the constructor was called to create the static instance or just any instance.
Now the Rdoc tag @allmethods takes an optional argument specifying if private, protected or public methods should be listed.
setClassS3(), which has been deprecated since 2003(!).showHistory() for the Package class was calling itself.
Compiling Rdoc comments with invalid keyword tags would generate an internal error. Same for invalid visibility tags etc.
Added getChangeLog() and showChangeLog() to the Package class. The get- and showHistory(), which are to be made deprecated in the future, are now wrappers for these two methods.
Added Rdoc tag @RdocPackage to generate <pkg>-package.Rd files.
Now the Rdoc compiler makes sure that the generated Rd files all starts with a letter or a digit. If not, it adds a default prefix (currently 000). If not, the new R v2.3.0 R CMD check may complaint about missing objects.
Added validation of arguments in replacement functions.
Added RCC validation of arguments in “picky” methods, e.g. $().
$<- function goes through alternatives where to save the new value, e.g. set<Name>(), <name> field, static <name> field etc. When a “match” found and the value was assigned, it did not return (except for the set<Name>() match), but instead continued search for the rest. One effect of this was that the new value was always assign to the static field too. The fix make the code run faster too. Thanks Edouard Duchesnay at Service Hospitalier Frédéric Joliot, Commissariat à l’Energie Atomique, France for spotting this.Added argument replaceNewline to getDescription() of Package.
Now as.character() of Package reports the title, the license, and the description, but no longer if the package is part of a bundle. The latter was too slow since it had to scan all installed packages.
Now print() of Class passes ... to getDetails(), that is, now print(Class, private = TRUE) will work too.
Added attachLocally() to the Object class.
Added extend.default(), which can be used to extend any type of object.
Now pure Object:s are also finalized. Before only subclasses defined via extend(<Object>, "<SubClass>", ...) was finalized. This was not a big deal, because the finalize():er of the Object class is empty anyway.
Rdoc$compile() sometimes generated the error invalid regular expression '\name{[^\}]*}' (forgot to escape { and }). Fixed. Thanks Lorenz Wernisch, School of Crystallography, University of London for reporting this.
getDetails() in Class would list private and protected methods as public.
Argument enforceRCC of setMethodS3() was not passed to setGenericS3().
Now the static load() method in Object asserts that the loaded Object inherits from the class that the static object, which is used to call load(), is of. Thus, Object$load(...) will load all Object:s, whereas MyClass$load(...) will only load objects inheriting from MyClass.
Now an @RdocMethod tag will not add keyword “internal” if the class starts with a lower case, e.g. matrix.
A @keyword foo can now be removed with @keyword -foo. Order is irrelevant, since @keyword:s are added at the very end.
getDevelUrl() to the Package class.Package now outputs “See ?R.oo for help” when loaded.
setMethodS3(..., abstract = TRUE) now defines abstract methods with ... as the only argument(s).
Now using three-digit version numbers, e.g. a.b.c where a,b,c in 0,1,…,9. ‘a’ is updated for major updates, ‘b’ for minor updates and ‘c’ is for minor revisions.
Removed require(methods) for R v2.0.0 and above.
get- & showDescription() to get- & showDescriptionFile() and added getDescription() to get the Description field of DESCRIPTION.setMethodS3() that is not using Object().R CMD check on R v2.1.0 devel also. Had to modify a few lines of code to meet the new stricter regular expression patterns.trycatch() in favor of tryCatch(). trycatch() remains for a while, but will be made deprecated in future version and later probably defunct.By default, now Rdoc$compile() runs Rdoc$check() at the end.
Rdoc: Added a first simple test for undefined top-level tags in the generated Rd code. Utilizes tools::Rd_parse(), which might be renamed etc. according to its help page.
Tag-variables such as @author now search for value in options() too.
getRdMethods() in Class returned empty \tabular{rll}{} if no methods exist, but this gives an error in R CMD Rdconv.When using setMethodS3(..., abstract = TRUE) in a package that uses lazy loading, which all new packages do by default, warnings like “using .GlobalEnv instead of package:utils” will be generated the first time the abstract method is accessed. This is because eval() is used to create the abstract method; we are looking for a way that will not generate these warnings, although they are not serious. Example: library(R.colors); print(getColorSpace.Color).
Added getEnvironment() to the Package class.
unload() for the Package class to load the boot package instead of obsolete ts.Substantially improved the loading of all my packages. The Package() constructor, which was called when a new package was loaded, was slow unnecessarily slow because of an internal call to installed.packages().
Added known generic function as.vector().
getInternalAddress() for class Object was “too” hard coded making it not work correctly on for instance Suse Linux. Assumed fixed positions of the hexadecimal address of the environment. Now a gsub() with a backreference is used. Should be more safe.Updated trycatch() (and the Exception class) to work with R v1.8.1. If running R v1.8.1, then tryCatch() is used internally. For R v1.7.1 and before the old trycatch() is used, which will be made deprecated later on. Added a throw() for the error class too for rethrowing errors.
Update the Rdoc compiler to generate correct \name and \alias Rd tags.
setClassS3(), please use setConstructorS3() instead; setClassS3() is deprecated and will be phased out soon!Package class - from R v1.8.1 we noted that R CMD check made installed.packages() return multiple matches of the same package. This might have been a problem before too, but R CMD check never complained.showDescription(), getHistory(), showHistory(), getHowToCite(), and showHowToCite() to the Package class.Package: update() does now also reload the updated package by default.
Exception: Now the throw() method includes the complete stacktrace too when generating a error signal. In other words, the user will automatically see the stacktrace of the error if the error is not caught. Same for stop().
Rdoc: Added the tag @RdocDocumentation for general documentation.
Added argument compress = TRUE to Object’s save() to make it more explicit that compression is supported too. Compression is supported by all R systems since R v1.5.0. See ?capabilities.
Now Rdoc tries to create the ‘man/’ (destPath) directory if missing.
$<-.Class was incorrectly returning the static object instead of itself.
The way $.Object, $<-.Object, $.Class and $<-.Class were checking if an attribute exists was not done correctly. Now they get the list of names of the attributes and compares to that.
If Object’s save() was called with a connection it would still interpret it as a filename.
getMethods() was not sensitive to deprecated = TRUE.dimension() would not always be found if ll() was called on another package, e.g. ll(envir = "methods").Added Rdoc comments saying that the constructor function must be able to be called without any arguments! Thanks Nathan Whitehouse at Baylor College of Medicine, Houston for making me aware of the missing documentation.
Rdoc$compile() generated an InternalException when a class was not found saying “Not a class”. Now it throws an RdocException and is more specific saying that the class does not exist. Updated the Rdoc comments saying pointing out that the classes and methods have to be loaded before calling Rdoc$compile(). Again, thanks Nathan.
Now the Rdoc compiler generates the correct \synopsis and \usage pairs. Before they were added either or, but that was a mistake by me. \synopsis should be added whenever the \usage statement is not complete.
update() of Package did not work. Did by mistake add a package argument to update.packages() too. That argument is only used in install.packages() though.
force = FALSE to update() in the Package class.R.oo: The Rdoc compiler was further improved and made more flexible. I am aiming to make it possible for the user to define their own simple tags.
All Rd files are now making use of \link[pkg:name]{label} for referring to methods not named according to the label. This is for instance the case with all class specific methods. More over, all Rd files for classes has \keyword{classes} and the \usage{} is used where it works and otherwise \synopsis{} is used (as recommended on the R help pages). All this is automatically taken care of by the Rdoc compiler.
Added getDocPath(), update(), and unload() to the Package class. With update() it is now possible to update a package or its bundle by just typing update(R.oo).
Added showAndAsk() to the Exception. It will, if tcltk is installed, display a dialog box with the error message. If tcltk is not installed, the message will be printed on the command line and a prompt requesting the user to press enter will be shown. showAndAsk() will give an error if run in a non-interactive mode.
Added almost all missing help pages, i.e. I wrote up a lot of Rd files. More help is still though for the Rdoc class, which compiles Rdoc comments in the source files into Rd files. However, if you want to use Rdoc$compile() already now, see the source files for plenty of examples and just run Rdoc$compile() in the same directory.
Spell correction: “c.f.” -> “cf.”
getStaticInstance() of class Class did not recover correctly if static instance was missing.Added getUrl(), getMaintainer(), getAuthor(), getTitle(), getLicense(), and getBundle(). Made the output from as.character() more informative.
Added a caching feature of $() to speed up access to members. The first time a member (field, virtual field, static field, method etc) is accessed it is done by looking it up one at the time and taking the first existing one (in a predefined order). The second time the same field is accessed, the name is remembered and $() access the right member directly. If this works out, $<-() will get a similar cache.
try(), which a slight modification to the base::try() for improved exception handling, to have its own internal restart() function (just like base::try()), because restart() has been made deprecated from R v1.6.0. This is how the try() in the base package does it.Added the finalizer method finalize(), which any subclass can override and that will be called by the garbage collector just before an object is about to be removed from the memory.
Added default function for equals().
Added argument overwrite = TRUE and conflict = c("error", "warning", "quiet") to setMethodS3().
Now extend() in class Object removes duplicated class attributes.
Now it is possible to create methods (also generic) with one (or several) . (period) as a prefix of the name. Such a method should be considered private in the same manner as fields with a period are private.
Added argument path = NULL to save() and load() in class Object. It will remove the need using paste() etc.
For ll(), replaced "getClass" with "data.class" in the properties argument. Since data.class is almost the same as mode, mode was also removed.
SPELL CHECK: “…name name…” in one of setGenericS3()’s error messages. Thanks Gordon Smyth, WEHI, Melbourne, for the comment.
setClassS3() to setConstructorS3(), since this is what it is actually doing. Keeping setClassS3() for backward compatibility but made it deprecated.Updated setGenericS3() to always create generic functions with no arguments except ... to follow the RCC.
Now $() and $<-() in class Object and Class also gets and sets attribute values too, respectively.
Added getInstanciationTime(), which returns the time point when the object was created.
Updated getField() of class Class to call generic method getField() and not getField.Object().
$<-() of class Class did not work for static fields.
getDetails() would not add a newline after the class name if the class did not have a superclass, i.e. for root class Object.
Decided to declare all Rd files for class methods as \keyword{internal} which means that they will not show up in the HTML table of contents. Only classes and stand-alone functions should be there.
The package now contains the public classes Object, Exception, RccViolationException. It also contains the internal classes Class, Package, and Rdoc. The class Class is essential, but Package and Rdoc are just utility classes containing useful static methods for development purposes etc.
The idea behind the Rx.oo package are the same as behind “old” R.oo, but internally environments are used for emulating references, whereas in R.oo a global so called object space was used. However, API-wise not much have been changed.
FYI: R.oo was first published in March 2001 and has undergone several updates, tests and bug fixes. Experience from that project has been brought into this package.
Added trial versions of extend() of class Object and class Reference. Also added trial version of superMethodS3() to replace faulty NextMethod().
Added as.Reference() to class Object and class Reference and made the constructor accept Reference objects by just returning them again. Before an exception was thrown.
Added argument showDeprecated = FALSE to classinfo() in class Class. This has the effected that when typing a name of a class and pressing enter at the prompt to display class information, deprecated method are not shown by default.
Added the class Class for dealing with static methods, static fields, accessing methods and fields of classes, generating class information etc. Since the handling of static methods and fields are now dealt by a specific class it means that the access of non-static methods and fields, which is done by the Object class, should now be a bit faster due to less overhead.
Internal updates: Made .ObjectSpace.count an internal variable of the .ObjectSpace environment, meaning that it is harder to delete it by mistake.
Added internal function getPackagePosition().
relibrary(R.oo) was reloading the .RObjectSpace file too, which is not a wanted feature.
setGenericS3() would sometimes believe that a non-function object actually was a function and tried to set it as a generic function, which resulted in an error exception.
createClassS3() would throw an error exception if there where two packages loaded such the name of the first one was the same as the beginning of the name of the second one, e.g. R.oo and *R.oo2.
Added the functions Q() and Quit() for quitting with the option to save the ObjectSpace also.
Added isGenericS3() and isGenericS4().
If trying to use delete() to remove a non-existing variable or Object now only a warning is given, before an exception was thrown which was quite annoying. delete() works as rm() plus it also deletes objects in ObjectSpace, which means that all calls to rm() can be replaced by calls to delete().
Added the static methods ObjectSpace$save() and ObjectSpace$load() to save and load an image of the ObjectSpace.
$ and [[ also searches for fields in attributes(). This is a first step towards making use of structure() and friends instead. I’ve been thinking about this from the very beginning, but newer done it. The plan is to move away from the internal list() and accept any R object as the core object. This will also be more consistent with the R.methods/S4 strategy.Moved about() from R.base to this package and removed old description().
Now the package reports its name, version and date if it was successfully loaded.
Minimized the number of warnings when loading packages.
Added argument dontWarn to setGenericS3(), which by default is set so no warnings are produced for renamed methods in the base package.
Copied packagePaths() from package R.base to package R.oo, since it is required in R.oo and we do not want R.oo to depend on R.base.
The classes Throwable and Exception have been transferred to here from the R.lang package. With the trycatch() they are really useful.
throw() and trycatch() are now available in both R.base and R.oo.
Added createClassS3() and internal variable .NewClassesNotCreated.
$.Object() and $.Reference() now returns NULL if a field/method etc is not found! Before it an error was thrown.
trycatch() didn’t work methods created by setMethodS3(). This was due to I did (internally):
object <- try(eval(substitute(object, envir=envir)))
instead of:
object <- try(eval(substitute(object), envir=envir))
Hmm, a tricky typo to find since it worked elsewhere.
Tiny bug fix in message of throw() clause in $().
Added a trial version of [.Reference. Currently, it does not support the get<Field name>() idea as described below. Maybe a [<-.Reference will be added later.
Added trial version of a new feature for Object/Reference fields. Now, if a field does not exist and there is no method with the same name, then, if a method named get<Field name>() exists, the value of get<Field name>(<object>) is returned. This way one can have fields that are generated “on the fly” to save memory etc. This new feature required that [[.Object was modified (actually created). Example: For an object obj one can get its class by either the classical getClass(obj) or by the new feature obj$Class. If this new feature are successful, I will also look at implementing a corresponding set<field name>() support.
setGenericS3() gave an error if one tried to set a generic function with the same name as an R object that was not a function. A simple add of argument mode = "function" to the exists() check fixed this.clone() in class Reference did not work properly; it gave the wrong internal reference names, which in turn would generate errors such as ‘Error in get(x, envir, mode, inherits) : variable “Reference.METHODS” was not found’ when one tried object$foo() instead of foo(object). Now it works again.IMPROVEMENT: Since library(methods) might be loaded after library(R.oo) the function extends() breaks down. Worked this out a little bit by detaching and reloading R.oo in function createClass() if it is detected that extends() has changed.
IMPROVEMENT: Forces extends <- function(...) UseMethod("extends"). The reason for doing this is that if we have anything but ... that argument might be matched by an attribute. Not good!
names() to the class Reference.When running the OO garbage collector, calling a finalize() that used the method super() failed with an exception. Internally, the class attributes of the freeable references were lost.
extends() and implements() in Rdoc sometime gave errors.
Renamed the (still) internal class .Reference to Reference.
Added the setInterfaceS3() method. Makes it easier to define interfaces.
Static method buildClass() in class Rdoc now also creates a list of methods and saves the result in the file <class>.methods.Rdoc, which can be included in the Rdoc comments by @include "<class>.methods.Rdoc". Hopefully, this will mean that the list of methods in the help files will be more up to date.
setClassS3(), setInterfaceS3(), and setMethodS3().trial, deprecated, static, protection, and abstract to setMethodS3() (and to some extend also to setClassS3()).setClassS3() and setMethodS3() internally.Internally renamed the methods, e.g. new(), getClass(), and extends(), that conflicted with methods defined in the new R package methods. Hopefully, these changes makes methods run when R.classes is loaded.
Starting to separate Object methods and .Reference methods. Eventually maybe R.oo Object’s could work very similar to methods object where .Reference is just an add-on to make the Object’s referensable.
getObject() and setObject() much less of interest and they will probably be made obsolete or private, which is another step towards a more user friendly oo core.Improved the error and warning messages for false references.
delete() can now remove any number of any kind of objects, i.e. it is now more consistent to rm().
Created this HISTORY file. Everything below is recreated from from this date and is therefore not complete.
myFcn = function() NULL and now one writes myFcn = METHOD where METHOD is predefined constant. This allows fields in a class to also contain functions, i.e. myField = sqrt(x), which was not possible in previous versions.