ClassUtils {methods} | R Documentation |
These are various functions to support the definition and use of formal classes. Most of them are rarely suitable to be called directly.
testVirtual(properties, extends, prototype) makePrototypeFromClassDef(properties, prototype, extends) newEmptyObject() completeClassDefinition(Class, ClassDef) getFromClassDef(ClassDef, what) setInClassDef(ClassDef, what, value, synchronize=TRUE) synchronizeClassDef(ClassDef) getProperties(ClassDef) setProperties(ClassDef, value) getSlots(x, complete = TRUE) getExtends(ClassDef) getAccess(ClassDef) getAllSuperClasses(ClassDef) superClassDepth(ClassDef, soFar) setExtends(ClassDef, value) getPrototype(ClassDef) setPrototype(ClassDef, value) getVirtual(ClassDef) isVirtualClass(Class) setVirtual(ClassDef, value) getSubclasses(ClassDef) setSubclasses(ClassDef, value) getClassName(ClassDef) setClassName(ClassDef, value) assignClassDef(Class, def, where=.GlobalEnv) newClassEnvironment(name, properties, extends, prototype, subclasses, virtual, validity, access) newBasic(Class, ..., .Force=FALSE) makeExtends(extends) reconcilePropertiesAndPrototype(name, properties, prototype, extends) tryNew(Class) empty.dump() showClass(Class, complete=TRUE, printTo=stdout(), propertiesAreCalled="Properties") showExtends(ext, printTo = stdout()) print.classRepEnvironment(x, ...) print.environment(x, ...) getFromClassMetaData(name) assignToClassMetaData(name, value) removeFromClassMetaData(name) extendsCoerce(fromClass, Class, formFunction) extendsReplace(fromClass, Class) findExtends(class1, class2) completeExtends(ClassDef, soFar) classMetaName(name) methodsMetaName(prefix, name) as.data.frame(x, row.names=NULL, optional=FALSE) requireMethods(functions, signature, message) checkSlotAssignment(obj, name, value) defaultPrototype() isClassDef(object)
testVirtual
:Otherwise, a class is virtual only if it has no slots, extends no non-virtual classes, and has a NULL Prototype
makePrototypeFromClassDef
:The following three rules are applied in this order.
If the class has slots, then the prototype for each slot is used by default, but a corresponding element in the explicitly supplied prototype, if there is one, is used instead (but it must be coercible to the class of the slot).
If there are no slots but a non-null prototype was specified, this is returned.
If there is a single non-virtual superclass (a class in the extends list), then its prototype is used.
If all three of the above fail, the prototype is NULL
.
newEmptyObject
:Currently just creates an empty list with class "NULL"
Later version should create a special object reference that marks an object currently with no slots and no data.
completeClassDefinition
:The completed definition is stored in the session's class metadata, to be retrieved the next time that getClass is called on this class, and is returned as the value of the call.
If ClassDef
is omitted, the initial definition is obtained from
the first package having a meta-object for this class.
getFromClassDef
:
setInClassDef
:
synchronizeClassDef
:Basically computes derived information used to make object manipulations more efficient but that need to be revised if information changes.
(Nothing at the moment)
getProperties
:
setProperties
:
getSlots
:complete
is TRUE
, all slots from all superclasses will
be included. The argument x
can either be the name of a
class or an object having that class.
getExtends
:
Contrast with the findExtends
and is
functions, both of which use indirect
information as well.
getAllSuperClasses
, superClassDepth
:
getAllSuperClasses
is a utility function used to complete a class definition.
It returns all the
superclasses reachable from this class, in breadth-first order (which is the order
used for matching methods); that is, the first direct superclass followed by all its
superclasses, then the next, etc. (The order is relevant only in the case that
some of the superclasses have multiple inheritance.)
superClassDepth
, which is called from getAllSuperClasses
,
returns the same information, but as a list with
components label
and depth
, the latter for the number of
generations back each class is in the inheritance tree. The argument
soFar
is used to avoid loops in the network of class relationships.
setExtends
:
getAccess
:
setPrototype
:
getVirtual
:
isVirtualClass
:A class is virtual if explicitly declared to be, and also if the class is not formally defined.
setVirtual
:
getSubclasses
:
setSubclasses
:
getClassName
:
setClassName
:
assignClassDef
:
newBasic
:new
for basic classes that don't have
a formal definition.
Any of these could have a formal definition, except for Class="NULL" (disallowed because NULL can't have attributes). For all cases except "NULL", the class of the result will be set to Class.
See new
for the interpretation of the arguments.
makeExtends
:
reconcilePropertiesAndPrototype
:
Specifically, returns a structure with attributes corresponding to the slot
names in properties and values taken from prototype if they exist there, from
new(classi)
for the class, classi
of the slot if that succeeds, and NULL
otherwise.
The prototype may imply slots not in the properties list, since properties does not include inherited slots (these are left unresolved until the class is used in a session).
tryNew
:This is inefficient and also not a good idea when actually generating objects, but is useful in the initial definition of classes.
showClass
:If complete==TRUE, include the indirect information about extensions.
showExtends
:Also used to print extensions recorded in the opposite direction, via a subclass list
print.environment, showNonVector
:print.environment
function exists to intercept printing based
on S3-style methods; it calls showNonVector
to do the work.
extendsCoerce
, extendsReplace
:is
relation
between two classes.
A method may be explicitly stored in the metadata or
inferred. If the latter, a function will always be constructed if
explicit test and/or coerce methods (in a call to setIs) were
encountered, or if formFunction=TRUE
. If
formFunction=FALSE
, the purpose of the call is to determine if
the relation is explicit or intrinsic (according to whether a function
object is returned).
findExtends
:This can be either a logical value or an object containing various functions to test and/or coerce the relationship.
completeExtends
:Elements in the immediate extends list may be added and current elements may be replaced, either by replacing a conditional relation with an unconditional one, or by adding indirect relations.
The resulting extends list is presented in depth-first order; that is, the first immediate superclass followed by all the indirect relations through it, then the next immediate superclass, etc.
Depth first order is required for consistent elaboration of inherited methods during dispatch, because the method dispatcher stores the inherited method under the immediate class name. Under rather obscure situations of multiple inheritance, the result could be ambiguous (depending on the order in which signatures are seen by the dispatcher for a particular generic function), unless searching is done depth first.
Used recursively, with soFar
defining what has been included in
previous calls at this level.
classMetaName
:
methodsMetaName
:
requireMethods
:
For each generic, setMethod
will be called to define a method that throws an error,
with the supplied message.
The requireMethods
function allows virtual classes to require actual classes that
extend them to implement methods for certain functions, in effect creating an API
for the virtual class.
Otherwise, default methods for the corresponding function would be called, resulting in less helpful error messages or (worse still) silently incorrect results.
checkSlotAssignment
:
For privileged slots (those that can only be set by accesor functions
defined along with the class itself), the class designer may
choose to improve efficiency by validating the value to be
assigned in the accessor function and then calling slot<-
with
the argument check=FALSE
, to prevent the call to checkSlotAssignment
.
defaultPrototype:
{
The prototype for a class which will have slots, is not a virtual
class, and does not extend one of the basic classes. In future
releases, this will likely be a non-vector R object type, but none
of the current types (as of release 1.4) is suitable.
}
.InitBasicClasses
, .InitMethodsListClass
,
.setCoerceGeneric
:.First.lib
.
isClassDef
:object
a representation of a class?