R: Internal Objects in Package 'base'

base-internal {base} | R Documentation

## Internal Objects in Package base

### Description

Internal objects in the base package, which are only user-visible because of the special nature of the base namespace.

### Usage

    .subset(x, ...)
    .subset2(x, ...)

    .getRequiredPackages(file = "DESCRIPTION", lib.loc = NULL,
                         quietly = FALSE, useImports = FALSE)
    .getRequiredPackages2(pkgInfo, quietly = FALSE, lib.loc = NULL,
                          useImports = FALSE)

    testPlatformEquivalence(built, run)

    .isMethodsDispatchOn(onOff = NULL)

    sys.load.image(name, quiet)
    sys.save.image(name)

    .row_names_info(x, type = 1L)
    .set_row_names(n)

    findPackageEnv(info)

    lazyLoadDBfetch(key, file, compressed, hook)

    .TAOCP1997init(seed)

    .gt(x, i, j)
    .gtn(x, strictly)

    .primTrace(obj)
    .primUntrace(obj)

    .POSIXct(xx, tz = NULL)
    .POSIXlt(xx, tz = NULL)
    .difftime(xx, units)

    .cache_class(class, extends)

    .find.package(...)
    .path.package(...)

### Arguments

`x` | object from which to extract elements.
`file` | The full path to the ‘DESCRIPTION’ file of a package.
`lib.loc` | a character vector describing the location of R library trees to search through, or `NULL`. The default value of `NULL` corresponds to all libraries currently known to `.libPaths()`.
`quiet` | logical. Should this not give warnings or an error if the package(s) are not found?
`useImports` | logical. Should the `Imports` field be processed?
`quietly` | logical: should message(s) be printed.
`pkginfo` | A processed ‘DESCRIPTION’ file of class `"packageDescription2"`.
`built, run` | platform strings of the form `"cpu-vendor-os"`.
`name` | name of image file to save or load.
`x` | an object with a `"row.names"` attribute, typically a data frame.
`type` | integer. Currently `type = 0` returns the internal `"row.names"` attribute (possibly `NULL`), `type = 2` the number of rows implied by the attribute, and `type = 1` the latter with a negative sign for ‘automatic’ row names.
`n` | integer. The number of rows.
`info` | character string such as `"package:MASS"`.
`key` | the object name in a lazyload database.
`file` | the filepath to a lazyload database.
`compressed` | logical: are the values in the database compressed?
`refhook` | a load hook: see `unserialize`.
`seed` | a length-one integer vector.
`i, j` | indices.
`strictly` | logical.
`obj` | an R object.
`xx` | a classless object to be placed into the class.
`tz` | an optional timezone.
`units` | see `difftime`.
`...` | Arguments passed to non-dot name versions.

### Details

The functions `.subset` and `.subset2` are essentially equivalent to the `[` and `[[` operators, except that methods dispatch does not take place. This is to avoid expensive unclassing when applying the default method to an object. They should not normally be invoked by end users. Note that unlike the operators they are builtins and not specials (all arguments are evaluated) and hence do not allow missing arguments.

`.getRequiredPackages2` attaches all the packages mentioned in the `Depends` field: failure to find a package is an error. It also checks the versions of the packages found against the `Depends` field.

`.getRequiredPackages` is a wrapper to `.getRequiredPackages2` using a ‘DESCRIPTION’ file.

`testPlatformEquivalence` is used to test if a package with compiled code can safely be loaded into a build of R, which it does by comparing their ‘canonical’ `"cpu-vendor-os"` descriptions. The default function omits the `vendor` part and allows small mismatches elsewhere. Cognoscenti can replace this function in the `base` namespace.

The function `.isMethodsDispatchOn()` returns `TRUE` if the S4 method dispatch has been turned on in the evaluator (usually by loading package methods). It is meant for R internal use only.

`sys.save.image` is a system function that is called by `q()` and its GUI analogs; `sys.load.image` is called by the startup code. These functions should not be called directly and are subject to change.

`sys.save.image` closes all connections first, to ensure that it is able to open a connection to save the image. This is appropriate when called from `q()` and allies, but reinforces the warning that it should not be called directly.

`row.names` can be stored internally in compact form. `.set_row_names(n)` generates that form for automatic row names of length `n`, to be assigned to `attr(<a data frame>, "row.names")`. `.row_names_info` gives information on the internal form of the row names for a data frame: for details of what information see the argument `type`.

`.GenericArgsEnv` and `.ArgsEnv` are environments that contain closures with the argument lists that the primitives would have had had they been closures. All the primitives that are internal S3 generics have corresponding members of `.GenericArgsEnv` and the remaining non-language-element primitives correspond to `.ArgsEnv`. See the ‘R Internals’ manual for further details. They are used by `args` and `print.default` and the QC functions `codoc` and `checkS3methods`.

`findPackageEnv` is invoked by the unserialize code to set a saved environment if possible.

`.TAOCP1997init` is the initialization code for the `"Knuth-TAOCP"` RNG.

`.gt` and `.gtn` are callbacks from `rank` and `is.unsorted` used for classed objects.

`.primTrace` and `.primUntrace` are the primitive functions underlying `trace` and `untrace` respectively.

`.POSIXct`, `.POSIXlt` and `.difftime` are class generators added in R 2.11.0.

`.cache_class` caches the inheritance of an S4 class for use in S3 method dispatch. With `NULL` second argument, returns the cached inheritance, for diagnostic use.

`.find.package` and `.path.package` are internal-only versions (and the only versions available prior to R 2.13.0) of `.find.package` and `.path.package`.

### Value

`.getRequiredPackages` and `.getRequiredPackages2` return `invisible()`.

`testPlatformEquivalence` returns `TRUE` or `FALSE`.

[Package base version 2.15.1 Index]