new file mode 100644

@@ -0,0 +1,65 @@

+## FunctionProducer

+

+.FunctionProducer <- 

+    setRefClass("FunctionProducer",

+        contains = "Producer",

+        fields = list(FUN = "function", RESET="function", state="ANY"))

+ 

+.FunctionProducer$methods(

+    reset = function()

+    {

+        "reset FunctionProducer"

+        if (verbose) msg("FunctionProducer$reset")

+        RESET(state)

+    },

+    yield = function()

+    {

+        "yield data from FunctionProducer"

+        if (verbose) msg("FunctionProducer$yield")

+        FUN()

+    })

+

+FunctionProducer <-

+    function(FUN, RESET, ..., state = NULL)

+{

+    if (missing(FUN))

+        FUN <- function() logical()

+    if (missing(RESET))

+        RESET = function(state)

+            stop("'reset()' not implemented for this FunctionProducer",

+                 call. = FALSE)

+    .FunctionProducer$new(FUN=FUN, RESET=RESET, state=state, ...)

+}

+

+## FunctionConsumer

+

+.FunctionConsumer <- 

+    setRefClass("FunctionConsumer",

+        contains = "Consumer",

+        fields = list(FUN = "function", RESET="function", state="ANY")) 

+ 

+.FunctionConsumer$methods(

+    reset = function()

+    {

+        "reset FunctionConsumer"

+        if (verbose) msg("FunctionConsumer$reset")

+        RESET(state)

+    },

+    yield = function()

+    {

+        "yield data from FunctionConsumer"

+        if (verbose) msg("FunctionConsumer$yield")

+        FUN(callSuper())

+    })

+

+FunctionConsumer <- function(FUN, RESET, ..., state=NULL)

+{

+    if (missing(FUN))

+        FUN = function(y) y

+    if (missing(RESET))

+        RESET = function(state)

+            stop("'reset()' no implemented for this FunctionConsumer",

+                 call.=FALSE)

+    .FunctionConsumer$new(FUN=FUN, RESET=RESET, state=state, ...)

+}

+

deleted file mode 100644

@@ -1,23 +0,0 @@

-.UserFunction <- 

-    setRefClass("UserFunction",

-        contains = "Consumer",

-        fields = list(FUN = "function")) 

- 

-.UserFunction$methods(

-    initialize = function(..., FUN)

-    {

-        "initialize myCons"

-        callSuper(..., FUN=FUN)

-    },

-    yield = function()

-    {

-        "yield data from UserFunction"

-        if (verbose) msg("UserFunction$yield")

-        FUN(callSuper())

-    })

-

-UserFunction <- function(FUN, ...)

-{

-    .UserFunction$new(FUN=FUN,...)

-}

-

new file mode 100644

@@ -0,0 +1,101 @@

+\name{FunctionProducerConsumer-classes}

+\Rdversion{1.1}

+\docType{class}

+

+\alias{FunctionProducerConsumer-classes}

+\alias{FunctionProducer}

+\alias{FunctionProducer-class}

+\alias{FunctionConsumer}

+\alias{FunctionConsumer-class}

+

+\title{Classes to create Producers and Consumers from functions}

+

+\description{

+

+  The \code{FunctionProducer} and \code{FunctionConsumer} classes

+  provide an easy way to quickly create \code{Producer} and

+  \code{Consumer} instances from user-provided functions.

+

+}

+

+\usage{

+FunctionProducer(FUN, RESET, ..., state=NULL)

+FunctionConsumer(FUN, RESET, ..., state=NULL)

+}

+

+\arguments{

+

+  \item{FUN}{User defined function to yield successive records in the

+    stream. The \code{FunctionProducer} function must return an object

+    of length 0 (e.g., \code{logical(0)}) when the stream is complete.}

+

+  \item{RESET}{An optional function of one arugment (\sQuote{state}) to

+    reset the stream to its original state. If missing, the stream

+    cannot be reset.}

+

+  \item{...}{Arguments passed to the \code{\linkS4class{Producer}}-class

+    or \code{\linkS4class{Consumer}}-class constructors.}

+

+  \item{state}{Any information, made available to \code{RESET}.}

+

+}

+

+\section{Constructors}{

+

+  Use \code{FunctionProducer} or \code{FunctionConsumer} to construct

+  instances of this class.

+

+}

+

+\section{Methods}{

+

+  See \code{\link{Producer}} and \code{\link{Consumer}} Methods.

+

+}

+

+\section{Internal Class Fields and Methods}{

+

+  Internal fields of this class are are described with, e.g.,

+  \code{getRefClass("FunctionProducer")$fields}.

+

+  Internal methods of this class are described with

+  \code{getRefClass("FunctionProducer")$methods()} and

+  \code{getRefClass("FunctionProducer")$help()}.

+

+}

+

+\author{Nishant Gopalakrishnan \url{ngopalak@fhcrc.org}}

+

+\seealso{\code{\link{stream}}}

+

+\examples{

+## A ProducerFunction

+producerFun <- function() 

+    ## produce the mean of 10 random uniform numbers

+    ## stop when the mean is greater than 0.8

+{

+    x <- mean(runif(10))

+    if (x > .8) numeric(0) else x

+}

+randomSampleMeans <- FunctionProducer(producerFun)

+result <- sapply(randomSampleMeans, c)

+length(result)

+head(result)

+

+## A FunctionConsumer:

+consumerFun <- function(y)

+    ## transform input by -10 log10

+{

+    -10 * log10(y)

+}

+

+neg10log10 <- FunctionConsumer(consumerFun)

+

+strm <- stream(randomSampleMeans, neg10log10)

+result <- sapply(strm, c)

+length(result)

+head(result)

+}

+

+\keyword{classes}

+

deleted file mode 100644

@@ -1,69 +0,0 @@

-\name{UserFunction-class}

-\Rdversion{1.1}

-\docType{class}

-\alias{UserFunction}

-\alias{UserFunction-class}

-

-\title{Class "UserFunction"}

-

-\description{

-

-  The \code{UserFunction} class is provided as a convenience class enabling

-  users to quickly create \code{Consumer}-classes that can be added to a stream

-  without having to go into more complex details about the implementation of the 

-  classes hierarchy provided by the \code{Streamer}-package.

-

-  The users pass in a function \code{fun} to the constructor of the

-  \code{UserFunction}-class to manipulate the records returned by

-  the class intended to be connected upstream. The constructor returns an

-  instance of the \code{UserFunction}-class with a with a

-  \code{yield} method that the user can directly invoke.

-}

-

-\usage{UserFunction(FUN, ...)}

-

-\arguments{

-   \item{FUN}{User defined function that operates on records yielded by the class

-       connected upstream.}

-  \item{...}{Arguments passed to the \code{\linkS4class{Consumer}}-class

-    constructors.}

-}

-

-\section{Constructors}{

-  Use \code{UserFunction} to construct instances of this class.

-}

-

-\section{Fields}{

-  \describe{

-

-    \item{\code{.FUN}:}{A user supplied\code{function} that operates on

-      records yielded by the class connected up-stream. }

-

-    }

-}

-

-\section{Methods}{There are no methods unique to this class.}

-

-\author{Nishant Gopalakrishnan \url{ngopalak@fhcrc.org}}

-

-\seealso{\code{\link{stream}}}

-

-\examples{

-f <- system.file("extdata", "s_1_sequence.txt", package="Streamer")

-b <- RawInput(f, 100L, reader=rawReaderFactory(1e4))

-### Create a user defined function to convert raw bytes to character

-myFun <- function(x) {

-    sapply(x, rawToChar)

-}

-

-#### Pass the function to the UserFunction constructor

-d <- UserFunction(myFun)

-

-#### Create a stream

-s <- stream(b, d)

-yield(s)

-

-}

-

-\keyword{classes}

-