\name{externalVectorWithStorage-class}
\docType{class}
\alias{externalVectorWithStorage-class}
\alias{Arith,ANY,externalVectorWithStorage-method}
\alias{Arith,externalVectorWithStorage,ANY-method}
\alias{Arith,externalVectorWithStorage,externalVectorWithStorage-method}
\alias{Arith,externalVectorWithStorage,missing-method}
\alias{Compare,ANY,externalVectorWithStorage-method}
\alias{Compare,externalVectorWithStorage,ANY-method}
\alias{Compare,externalVectorWithStorage,externalVectorWithStorage-method}
\alias{Complex,externalVectorWithStorage-method}
\alias{Math,externalVectorWithStorage-method}
\alias{Ops,ANY,externalVectorWithStorage-method}
\alias{Ops,externalVectorWithStorage,ANY-method}
\alias{Summary,externalVectorWithStorage-method}
\alias{Summary,externalVectorWithStorage,missing-method}
\alias{Summary,externalVectorWithStorage,logical-method}
\alias{[,externalVectorWithStorage,ANY,ANY,ANY-method}
\alias{[<-,externalVectorWithStorage,ANY,ANY,externalVectorWithStorage-method}
\alias{[<-,externalVectorWithStorage,ANY,ANY,ANY-method}
\alias{as.Rvector,externalVectorWithStorage-method}
\alias{asEach,externalVectorWithStorage,character-method}
\alias{colMeans,externalVectorWithStorage,missing,missing-method}
\alias{colMeans,externalVectorWithStorage,missing,ANY-method}
\alias{colMeans,externalVectorWithStorage,ANY,missing-method}
\alias{colMeans,externalVectorWithStorage,logical,numeric-method}
\alias{colSums,externalVectorWithStorage,missing,missing-method}
\alias{colSums,externalVectorWithStorage,missing,ANY-method}
\alias{colSums,externalVectorWithStorage,ANY,missing-method}
\alias{colSums,externalVectorWithStorage,logical,numeric-method}
\alias{dim,externalVectorWithStorage-method}
\alias{dim<-,externalVectorWithStorage,NULL-method}
\alias{dim<-,externalVectorWithStorage,ANY-method}
\alias{dimnames,externalVectorWithStorage-method}
\alias{getExternalStorage,externalVectorWithStorage-method}
\alias{getNativeStorageMethods,externalVectorWithStorage-method}
\alias{initialize,externalVectorWithStorage-method}
\alias{is.finite,externalVectorWithStorage-method}
\alias{is.infinite,externalVectorWithStorage-method}
\alias{is.na,externalVectorWithStorage-method}
\alias{is.nan,externalVectorWithStorage-method}
\alias{length,externalVectorWithStorage-method}
\alias{length<-,externalVectorWithStorage-method}
\alias{log,externalVectorWithStorage-method}
\alias{match,ANY,externalVectorWithStorage-method}
\alias{match,externalVectorWithStorage,ANY-method}
\alias{names,externalVectorWithStorage-method}
\alias{names<-,externalVectorWithStorage,NULL-method}
\alias{rebind,externalVectorWithStorage-method}
\alias{rowMeans,externalVectorWithStorage,missing,missing-method}
\alias{rowMeans,externalVectorWithStorage,missing,ANY-method}
\alias{rowMeans,externalVectorWithStorage,ANY,missing-method}
\alias{rowMeans,externalVectorWithStorage,logical,numeric-method}
\alias{rowSums,externalVectorWithStorage,missing,missing-method}
\alias{rowSums,externalVectorWithStorage,missing,ANY-method}
\alias{rowSums,externalVectorWithStorage,ANY,missing-method}
\alias{rowSums,externalVectorWithStorage,logical,numeric-method}
\alias{setDimNames,externalVectorWithStorage-method}
\alias{setNames,externalVectorWithStorage-method}
\alias{lapply,externalVectorWithStorage-method}

\title{Class "externalVectorWithStorage", external vector class with
  an external storage for the vector }
\description{ This is a subclass of \code{"externalVector"} that
  implements the use of arbitrary external backends for storing the
  elements of the vector. }
\section{Objects from the Class}{
  Objects can be created by calls of the form \code{externalVector(type,
  lengtyh, storageClass)}.
}
\section{Slots}{
  \describe{
    \item{\code{storage}:}{Object of class \code{"externalStorage"}, the
    storage backend for the vector elements. }
    \item{\code{Names}:}{Object of class \code{"vectorNamesType"}, names
      of the elements. }
    \item{\code{Dim}:}{Object of class \code{"integerOrNull"}, dimension
      of the object. }
    \item{\code{DimNames}:}{Object of class \code{"listOrNull"},
      dimnames of the object }
  }
}
\section{Extends}{
Class \code{"externalVector"}, directly.
Class \code{"vectorNamesType"}, directly.
}
\section{Methods}{
  \describe{
    \item{e1 op e2}{ For any arithmetic or comparison operation \code{op}
      this returns the result of the operation. Either (or both) of
      \code{e1} and \code{e2} are of class
      \code{"externalVectorWithSTorage"}. }
    \item{Complex(z)}{ Return the result of an operation in the
      \code{Complex} group generic. }
    \item{Math(x)}{ Return the result of an operation in the
      \code{Math} group generic. }
    \item{Summary(x)}{ Return the result of an operation in the
      \code{Summary} group generic. }
    \item{log(x)}{ Return natural logarithm of \code{x}. }
    \item{log(x, base)}{ Return logarithm of \code{x} with base
      \code{base}. }
    \item{x[i, j, \dots, drop=FALSE]}{ Extract a subset of \code{x}
      according to the given subscripts. }
    \item{x[i, j, \dots] <- value}{ Subassign of \code{x} by \code{value}
      according to the given subscripts. }
    \item{as.Rvector(x)}{ Coerce \code{x} to a basic R vector with same
      names, dimension and dimnames (if any of these are present in
      \code{x}). }
    \item{asEach(x, type, arrayOnly)}{ Coerce \code{x} so that it now
      behaves like a basic R vector with the same class as \code{type}.}
    \item{colSums(x, na.rm, dims)}{ Return the column sums of
      \code{x}. }
    \item{colMeans(x, na.rm, dims)}{ Return the column means of
      \code{x}. }
    \item{rowSums(x, na.rm, dims)}{ Return the row sums of
      \code{x}. }
    \item{rowMeans(x, na.rm, dims)}{ Return the row means of
      \code{x}. }
    \item{dim(x)}{ Return the dimension of \code{x}. }
    \item{dim(x) <- value}{ Set the dimension of \code{x} to \code{value}. }
    \item{dimnames(x)}{ Return the dimnames of \code{x}. }
    \item{getExternalStorage(x)}{ Return the \code{storage} slot of
      \code{x}. }
    \item{getNativeStorageMethods}{ Return
      \code{getNativeStorageMethods(x@storage)}. }
    \item{is.finite(x)}{ Return an external vector of logicals with same
      length as \code{x} indicating if an element of \code{x} is finite. }
    \item{is.infinite(x)}{ Return an external vector of logicals with same
      length as \code{x} indicating if an element of \code{x} is infinite. }
    \item{is.na(x)}{ Return an external vector of logicals with same
      length as \code{x} indicating if an element of \code{x} is \code{NA}. }
    \item{is.nan(x)}{ Return an external vector of logicals with same
      length as \code{x} indicating if an element of \code{x} is \code{NaN}. }
    \item{length(x)}{ Return the length of \code{x}. }
    \item{length(x) <- value}{ Set the length of \code{x} to \code{value}. }
    \item{names(x)}{ Return the names of \code{x}. }
    \item{names(x) <- value}{ Set the names of \code{x} to
      \code{value}. }
    \item{lapply(X, FUN, \dots)}{ Lapply for "externalVectorWithStorage"
      class. }
    \item{setDimNames(x, value)}{ Set the dimnames of \code{x} to
      \code{value} without any error checking or coercion. Return the
      modified \code{x}. }
    \item{setNames(x, value)}{ Set the names of \code{x} to \code{value}
      without any error checking or coercion. Return the modified
      \code{x}. }
    \item{rebind(x, length.x = length(x), type = defaultElement(x),
                 names.x = names(x), dim.x = dim(x), dimnames.x =
		 dimnames(x), \dots, arrayOnly = FALSE)}{ Create an
		 \code{"externalVectorWithStorage"} object with the same
		 external storage backend class as \code{x} but with
		 (possibly) new length, type, names, dim or dimnames. If
		 arrayOnly is FALSE, the names, dim and dimnames for the
		 new object are not set. }
    \item{initialize(.Object, \dots)}{ Initialize a new object from class
      \code{"externalVectorWithSTorage"}. }
  }
}
\seealso{
  \code{\link{externalVector}} and \code{\link{externalMatrix}} for how
  how to create new objects from this class easily.
}
\keyword{classes}