@@ -50,6 +50,6 @@

         inp <- rev(inputs())

         indx <- !inp %in%"TOut" 

         inp <- paste(inp[indx], collapse=" => ")

-        txt <- sprintf("stream: %s", inp)

+        txt <- sprintf("Stream: %s", inp)

         cat(strwrap(txt, exdent=2), sep="\n")

     })

@@ -25,9 +25,7 @@ FunctionProducer <-

     if (missing(FUN))

         FUN <- function() logical()

     if (missing(RESET))

-        RESET = function(state)

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

-                 call. = FALSE)

+        RESET = function(state) {}

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

 }

@@ -57,9 +55,7 @@ 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)

+        RESET = function(state) {}

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

 }

@@ -1,6 +1,6 @@

-.stream_set <- function(x, ..., verbose)

+.Stream_set <- function(x, ..., verbose)

 {

-    ## helper used to construct streams

+    ## helper used to construct Streams

     inp <- list(x, ...)

     use <- sapply(inp, "[[", "inUse")

     cls <- sapply(inp, class)

@@ -25,13 +25,13 @@

     .Stream$new(inputPipe=inputPipe, verbose=verbose)

 }

-setMethod(stream, "Producer",

+setMethod(Stream, "Producer",

     function(x, ..., verbose=FALSE)

 {

     if (0L == length(list(...)))

-        .stream_set(x, verbose=verbose)

+        .Stream_set(x, verbose=verbose)

     else

-        do.call(stream, c(rev(list(..., verbose=verbose)), list(x)))

+        do.call(Stream, c(rev(list(..., verbose=verbose)), list(x)))

 })

-setMethod(stream, "Consumer", .stream_set)

+setMethod(Stream, "Consumer", .Stream_set)

Binary files a/inst/doc/Streamer.Rnw and b/inst/doc/Streamer.Rnw differ

@@ -1,21 +1,21 @@

 test_Reducer <- function()

 {

-    s <- stream(Seq(to=10), Reducer("+"))

+    s <- Stream(Seq(to=10), Reducer("+"))

     checkIdentical(sum(1:10), yield(s))

     checkIdentical(numeric(), yield(s))

-    s <- stream(Seq(to=10, yieldSize=5L), Reducer("+"))

+    s <- Stream(Seq(to=10, yieldSize=5L), Reducer("+"))

     checkIdentical(1:5 + 6:10, yield(s))

     checkIdentical(numeric(), yield(s))

     ## init

-    s <- stream(Seq(to=10), Reducer("+", init=10L))

+    s <- Stream(Seq(to=10), Reducer("+", init=10L))

     checkIdentical(10L + sum(1:10), yield(s))

     checkIdentical(numeric(), yield(s))

     ## yieldNth

-    s <- stream(Seq(to=10), Reducer("+", yieldNth=5))

+    s <- Stream(Seq(to=10), Reducer("+", yieldNth=5))

     checkIdentical(c(sum(1:5), sum(6:10)), sapply(s, c))

     checkIdentical(numeric(), yield(s))

     ## reset

-    s <- stream(Seq(to=10), Reducer("+", init=10L)); yield(s)

+    s <- Stream(Seq(to=10), Reducer("+", init=10L)); yield(s)

     reset(s)

     checkIdentical(10L + sum(1:10), yield(s))

     checkIdentical(numeric(), yield(s))

@@ -4,6 +4,6 @@ test_Rev <-

     checkTrue(validObject(Rev()))

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

-    s <- stream(Rev(), RawInput(fl))

+    s <- Stream(Rev(), RawInput(fl))

     res <- yield(s)

 }

@@ -6,35 +6,29 @@

 test_Stream_producer <- function()

 {

-    ## stream() should produce a stream with only a producer

+    ## Stream() should produce a stream with only a producer

     p <- getRefClass("Producer")$new()

-    .checkStream(stream(p))

+    .checkStream(Stream(p))

 }

 test_Stream_consumer <- function()

 {

-    ## stream() should error with only a consumer (?)

+    ## Stream() should error with only a consumer (?)

     DEACTIVATED("should error with only a consumer (?)")

     c <- getRefClass("Consumer")$new()

-    checkException(stream(c))

+    checkException(Stream(c))

 }

 test_Stream_producer_consumer <- function()

 {

-    ## stream should succeed with producer / consumer in any order

+    ## Stream should succeed with producer / consumer in any order

     p <- getRefClass("Producer")$new()

     c <- getRefClass("Consumer")$new()

-    .checkStream(s1 <- stream(c, p))

+    .checkStream(s1 <- Stream(c, p))

     p <- getRefClass("Producer")$new()

     c <- getRefClass("Consumer")$new()

-    .checkStream(s2 <- stream(p, c))

+    .checkStream(s2 <- Stream(p, c))

     checkEquals(s1, s2)

 }

-

-test_Stream_yieldSize <- function()

-{

-    ## stream should obey overall yield size

-    

-}

@@ -3,16 +3,16 @@ test_MulticoreTeam_yield <- function()

     if (.Platform$OS.type != "unix")

         return()

     t <- Team(function(i) i, param=MulticoreParam(1L))

-    s <- stream(Seq(to=10), t)

+    s <- Stream(Seq(to=10), t)

     checkIdentical(1L, yield(s))

     checkIdentical(2L, yield(s))

     t <- Team(function(i) i, param=MulticoreParam(1L))

-    s <- stream(Seq(to=10), t)

+    s <- Stream(Seq(to=10), t)

     checkIdentical(1:10, sapply(s, c))

     t <- Team(function(x) mean(x), param=MulticoreParam(5L))

-    s <- stream(Seq(to=50, yieldSize=5), t)

+    s <- Stream(Seq(to=50, yieldSize=5), t)

     exp <- as.vector(sapply(split(1:50, rep(1:10, each=5)), mean))

     checkIdentical(exp, sapply(s, c))

 }

@@ -14,7 +14,7 @@

   \code{Consumer} instances. A \code{Consumer} typically transforms

   records from one form to another. \code{Producer} and \code{Consumer}

   instances are associated with each other through the

-  \code{\link{stream}} function or using the \code{\link{connect}} function.

+  \code{\link{Stream}} function.

 }

@@ -23,8 +23,8 @@

   \describe{

-    \item{stream}{Construct a stream from one \code{Producer} and one or

-      more \code{Consumer}. See \code{?stream}.}

+    \item{Stream}{Construct a stream from one \code{Producer} and one or

+      more \code{Consumer}. See \code{?Stream}.}

   }

 }

@@ -47,7 +47,7 @@ Downsample(probability=0.1, sampledSize=1e6, ...)

 \author{Martin Morgan \url{mtmorgan@fhcrc.org}}

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

+\seealso{\code{\link{Stream}}}

 \examples{showClass("Downsample")}

@@ -66,7 +66,7 @@ FunctionConsumer(FUN, RESET, ..., state=NULL)

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

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

+\seealso{\code{\link{Stream}}}

 \examples{

 ## A ProducerFunction

@@ -91,7 +91,7 @@ consumerFun <- function(y)

 neg10log10 <- FunctionConsumer(consumerFun)

-strm <- stream(randomSampleMeans, neg10log10)

+strm <- Stream(randomSampleMeans, neg10log10)

 result <- sapply(strm, c)

 length(result)

 head(result)

@@ -15,13 +15,14 @@

   instance. A \code{Producer} represents a source of data, responsible

   for parsing a file or other data source into records to be passed to

   \code{Consumer} classes. \code{Producer} and \code{Consumer} instances

-  are associated with each other through the \code{\link{stream}}

-  function or using the \code{\link{connect}} function.

+  are associated with each other through the \code{\link{Stream}}

+  function.

 }

 \usage{

 \S4method{lapply}{Producer}(X, FUN, ...)

+

 \S4method{sapply}{Producer}(X, FUN, ..., simplify=TRUE, USE.NAMES=TRUE)

 }

@@ -47,8 +48,8 @@

   \describe{

-    \item{stream}{Construct a stream from one \code{Producer} and one or

-      more \code{Consumer}. See \code{?stream}.}

+    \item{Stream}{Construct a stream from one \code{Producer} and one or

+      more \code{Consumer}. See \code{?Stream}.}

     \item{yield}{Yield a single result (e.g., \code{data.frame}) from

       the Producer.}

@@ -15,7 +15,7 @@

   A \code{\linkS4class{Producer}}-class to interpret files as raw

   (binary) data. Users interact with this class through the constructor

   \code{\link{RawInput}} and methods \code{\link{yield}},

-  \code{\link{reset}}, and \code{\link{stream}}.

+  \code{\link{reset}}, and \code{\link{Stream}}.

   This class requires two helper functions; the \sQuote{factory} methods

   defined on this page can be used to supply these.

@@ -107,7 +107,7 @@ rawParserFactory(separator = charToRaw("\n"), trim = separator)

 \author{Martin Morgan \url{mtmorgan@fhcrc.org}}

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

+\seealso{\code{\link{Stream}}}

 \examples{

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

@@ -52,18 +52,18 @@ Reducer(FUN, init, ..., yieldNth = NA_integer_)

 \author{Martin Morgan \url{mtmorgan@fhcrc.org}}

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

+\seealso{\code{\link{Stream}}}

 \examples{

-s <- stream(Seq(to=10), Reducer("+"))

+s <- Stream(Seq(to=10), Reducer("+"))

 yield(s)     ## sum(1:10), i.e., Reduce over the entire stream

-s <- stream(Seq(to=10), Reducer("+", yieldNth=5))

+s <- Stream(Seq(to=10), Reducer("+", yieldNth=5))

 yield(s)     ## sum(1:5)

 yield(s)     ## sum(6:10)

-s <- stream(Seq(to=10), Reducer("+", init=10, yieldNth=5))

+s <- Stream(Seq(to=10), Reducer("+", init=10, yieldNth=5))

 sapply(s, c) ## 10 + c(sum(1:5), sum(6:10))

 if (.Platform$OS.type != "windows") {

-    s <- stream(Seq(to=10),

+    s <- Stream(Seq(to=10),

                 Team(function(i) { Sys.sleep(1); i },

                      param=MulticoreParam(10L)),

                 Reducer("+"))

@@ -55,7 +55,7 @@ Seq(from = 1L, to=.Machine$integer.max, by = 1L, yieldSize=1L,

 \author{Martin Morgan \url{mtmorgan@fhcrc.org}}

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

+\seealso{\code{\link{Stream}}}

 \examples{

 s <- Seq(1, 10, yieldSize=5)

@@ -22,8 +22,11 @@

 \usage{

 \S4method{length}{Stream}(x)

+

 \S4method{[[}{Stream,numeric}(x, i, j, ...)

+

 \S4method{lapply}{Stream}(X, FUN, ...)

+

 \S4method{sapply}{Stream}(X, FUN, ..., simplify=TRUE, USE.NAMES=TRUE)

 }

@@ -48,8 +51,8 @@

 }

 \section{Constructors}{

-  Instances from this class are constructed with calls to \code{stream};

-  see \code{?stream}

+  Instances from this class are constructed with calls to \code{Stream};

+  see \code{?Stream}

 }

 \section{Methods}{

@@ -17,12 +17,12 @@

 }

 \details{

-  The central paradigm in this package is a \code{stream} composed of a

+  The central paradigm in this package is a \code{Stream} composed of a

   \code{\linkS4class{Producer}} and zero or more

   \code{\linkS4class{Consumer}} components. The \code{Producer} is

   responsible for input of data, e.g., from the file system. A

   \code{Consumer} accepts data from a \code{Producer} and performs

-  transformations on it. The \code{\link{stream}} function is used to

+  transformations on it. The \code{\link{Stream}} function is used to

   assemble a \code{Producer} and zero or more \code{Consumer} components

   into a single string.

@@ -41,7 +41,7 @@

 \seealso{

   \code{\linkS4class{Producer}}, \code{\linkS4class{Consumer}} are the

-  main types of stream components. Use \code{\link{stream}} to connect

+  main types of stream components. Use \code{\link{Stream}} to connect

   components, and \code{\link{yield}} to iterate a stream.

 }

@@ -57,13 +57,13 @@ getClass("Consumer")            # Consumer classes

 ## An example

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

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

-s <- stream(RawToChar(), Rev(), b)

+s <- Stream(RawToChar(), Rev(), b)

 s

 head(yield(s)) 			# First chunk

 b <- RawInput(fl, 5000L, verbose=TRUE)

 d <- Downsample(sampledSize=50)

-s <- stream(RawToChar(), d, b)

+s <- Stream(RawToChar(), d, b)

 s

 s[[2]]

@@ -9,7 +9,7 @@

 \alias{Team,MulticoreParam-method}

-\title{Consumer classes to enable parallel evaluation}

+\title{Consumer classes for parallel evaluation}

 \description{

@@ -19,8 +19,7 @@

 }

 \usage{

-\S4method{Team}{missing}(FUN, ..., param)

-\S4method{Team}{MulticoreParam}(FUN, ..., param)

+Team(FUN, ..., param)

 }

 \arguments{

@@ -32,8 +31,8 @@

   \item{...}{Additional arguments (e.g., \code{verbose}, passed to the

     \code{\linkS4class{Consumer}} constructor.}

-  \item{param}{A \code{ParallelParam} instance, such as generated by

-    \code{MulticoreParam()}.}

+  \item{param}{If provided, a \code{ParallelParam} instance, such as

+    generated by \code{MulticoreParam()}.}

 }

@@ -66,8 +65,8 @@

 \seealso{

   \code{\link{ParallelParam}} for configuring parallel

-  environments. \code{\link{TConnector}} to apply \emph{different}

-  functions to all elements of the team.

+  environments. \code{\link{DAGTeam}} apply functions organized as a

+  directed acyclic graph.

 }

@@ -75,7 +74,7 @@

 if (.Platform$OS.type != "windows") {

     param <- MulticoreParam(size=5)

     team <- Team(function(x) { Sys.sleep(1); mean(x) }, param=param)

-    s <- stream(Seq(to=50, yieldSize=5), team)

+    s <- Stream(Seq(to=50, yieldSize=5), team)

     system.time({while(length(y <- yield(s)))

         print(y)

     })  ## about 2 seconds

@@ -16,12 +16,14 @@

 \usage{

 reset(x, ...)

-\S4method{reset}{Streamer}(x, ...)

 }

 \arguments{

+

   \item{x}{A \code{Stream}, \code{Producer}, or \code{Consumer} object.}

+

   \item{\dots}{Additional arguments, currently unused.}

+

 }

 \value{

@@ -35,13 +37,13 @@ reset(x, ...)

 \seealso{

-  \code{\link{stream}}, \code{\linkS4class{Producer}},

+  \code{\link{Stream}}, \code{\linkS4class{Producer}},

   \code{\linkS4class{Consumer}}.

 }

 \examples{

-## see example(stream)

+## see example(Stream)

 }

 \keyword{methods}

@@ -15,6 +15,7 @@

 \usage{

 status(x, ...)

+

 \S4method{status}{Streamer}(x, ...)

 }

@@ -33,13 +34,13 @@ status(x, ...)

 \seealso{

-  \code{\link{stream}}, \code{\linkS4class{Producer}},

+  \code{\link{Stream}}, \code{\linkS4class{Producer}},

   \code{\linkS4class{Consumer}}.

 }

 \examples{

-## see example(stream)

+## see example(Stream)

 }

 \keyword{ manip }

@@ -1,23 +1,21 @@

-\name{stream}

+\name{Stream}

-\alias{stream}

-\alias{stream-methods}

-\alias{stream,Consumer-method}

-\alias{stream,Producer-method}

+\alias{Stream}

+\alias{Stream-methods}

+\alias{Stream,Consumer-method}

+\alias{Stream,Producer-method}

 \title{Function to create a Stream from a Producer and zero or more Consumers}

 \description{

-  \code{stream} is used to create a stream from a single \code{Producer}

+  \code{Stream} is used to create a stream from a single \code{Producer}

   and zero or more \code{Consumer} instances.

 }

 \usage{

-stream(x, ..., verbose=FALSE)

-\S4method{stream}{Producer}(x, ..., verbose=FALSE)

-\S4method{stream}{Consumer}(x, ..., verbose=FALSE)

+Stream(x, ..., verbose=FALSE)

 }

 \arguments{

@@ -29,16 +27,16 @@ stream(x, ..., verbose=FALSE)

 \details{

-  Arguments to \code{stream} must consist of a single \code{Producer}

+  Arguments to \code{Stream} must consist of a single \code{Producer}

   and zero or more \code{Consumer} components.

   When invoked with the \code{Producer} as the first argument,

-  \code{stream(P, C1, C2)} produces a stream in which the data is read

+  \code{Stream(P, C1, C2)} produces a stream in which the data is read

   by \code{P}, then processed by \code{C1}, then processed by \code{C2}.

   When invoked with the \code{Consumer} as the first argument, the

   \code{...} must include a \code{Producer} as the \emph{last}

-  argument. \code{stream(C1, C2, P)} produces a stream in which the data

+  argument. \code{Stream(C1, C2, P)} produces a stream in which the data

   is read by \code{P}, then processed by \code{C2}, then processed by

   \code{C1}.

@@ -53,7 +51,7 @@ stream(x, ..., verbose=FALSE)

 \examples{

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

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

-s <- stream(b, Rev(), RawToChar())

+s <- Stream(b, Rev(), RawToChar())

 s

 yield(s)

 reset(s)

@@ -16,12 +16,14 @@

 \usage{

 yield(x, ...)

-\S4method{yield}{Streamer}(x, ...)

 }

 \arguments{

+

   \item{x}{A \code{Stream}, \code{Producer}, or \code{Consumer} object.}

+

   \item{\dots}{Additional arguments, currently unused.}

+

 }

 \value{

@@ -35,13 +37,13 @@ yield(x, ...)

 \seealso{

-  \code{\link{stream}}, \code{\linkS4class{Producer}},

+  \code{\link{Stream}}, \code{\linkS4class{Producer}},

   \code{\linkS4class{Consumer}}.

 }

 \examples{

-## see example(stream)

+## see example(Stream)

 }

 \keyword{ manip }