R.oo: setConstructorS3 – R documentation

Become an expert in R — Interactive courses, Cheat Sheets, certificates and more!

setConstructorS3

Defines a class in S3/UseMethod style

Description

Defines a class in R.oo/S3 style. What this function currently does is simply creating a constructor function for the class.

Usage

## Default S3 method:
setConstructorS3(name, definition, private=FALSE, protected=FALSE, export=TRUE,
  static=FALSE, abstract=FALSE, trial=FALSE, deprecated=FALSE, envir=parent.frame(),
  enforceRCC=TRUE, ...)

Arguments

`name`	The name of the class.
`definition`	The constructor definition. Note: The constructor must be able to be called with no arguments, i.e. use default values for all arguments or make sure you use `missing()` or similar!
`static`	If `TRUE` this class is defined to be static, otherwise not. Currently this has no effect expect as an indicator.
`abstract`	If `TRUE` this class is defined to be abstract, otherwise not. Currently this has no effect expect as an indicator.
`private`	If `TRUE` this class is defined to be private.
`protected`	If `TRUE` this class is defined to be protected.
`export`	A `logical` setting attribute `"export"`.
`trial`	If `TRUE` this class is defined to be a trial class, otherwise not. A trial class is a class that is introduced to be tried out and it might be modified, replaced or even removed in a future release. Some people prefer to call trial versions, beta version. Currently this has no effect expect as an indicator.
`deprecated`	If `TRUE` this class is defined to be deprecated, otherwise not. Currently this has no effect expect as an indicator.
`envir`	The environment for where the class (constructor function) should be stored.
`enforceRCC`	If `TRUE`, only class names following the R Coding Convention is accepted. If the RCC is violated an RccViolationException is thrown.
`...`	Not used.

Note: If a constructor is not declared to be private nor protected, it will be declared to be public.

A constructor must be callable without arguments

The requirement that a constructor function should be callable without arguments (e.g. MyConstructor()) is because that call is used to create the static instance of a class. The reason for this is that a static instance of the class is created automatically when the constructor is called the first time (only), that is, when the first of object of that class is created. All classes have to have a static instance.

To make a constructor callable without arguments, one can either make sure all arguments have default values or one can test for missing arguments using missing(). For instance the following definition is not correct: setConstructorS3("Foo", function(x) extend(Object(), "Foo", x=x)) whereas this one is setConstructorS3("Foo", function(x=NA) extend(Object(), "Foo", x=x))

Code validation

If argument enforceRCC is TRUE, the class name is validated so it starts with a letter and it also gives a warning if its first letter is not capital. The reason for this is to enforce a naming convention that names classes with upper-case initial letters and methods with lower-case initial letters (this is also the case in for instance Java).

Author(s)

Henrik Bengtsson

Examples

## Not run: For a complete example see help(Object).

R.oo

R Object-Oriented Programming with or without References

v1.24.0

LGPL (>= 2.1)

Authors

Henrik Bengtsson [aut, cre, cph]

Initial release