\HeaderA{FilterRules-class}{Collection of Filter Rules}{FilterRules.Rdash.class}
\aliasA{active,FilterRules-method}{FilterRules-class}{active,FilterRules.Rdash.method}
\aliasA{active<-,FilterRules-method}{FilterRules-class}{active<.Rdash.,FilterRules.Rdash.method}
\aliasA{append,FilterRules,FilterRules-method}{FilterRules-class}{append,FilterRules,FilterRules.Rdash.method}
\aliasA{c,FilterRules-method}{FilterRules-class}{c,FilterRules.Rdash.method}
\aliasA{eval,FilterRules,ANY-method}{FilterRules-class}{eval,FilterRules,ANY.Rdash.method}
\aliasA{FilterRules}{FilterRules-class}{FilterRules}
\aliasA{[,FilterRules-method}{FilterRules-class}{[,FilterRules.Rdash.method}
\aliasA{[[<-,FilterRules-method}{FilterRules-class}{[[<.Rdash.,FilterRules.Rdash.method}
\keyword{classes}{FilterRules-class}
\keyword{methods}{FilterRules-class}
\begin{Description}\relax
A \code{FilterRules} object is a collection of filter
rules, which can be either \code{expression} or \code{function}
objects. Rules can be disabled/enabled individually, facilitating
experimenting with different combinations of filters.
\end{Description}
\begin{Details}\relax
It is common to split a dataset into subsets during data
analysis. When data is large, however, representing subsets (e.g. by
logical vectors) and storing them as copies might become too costly in
terms of space. The \code{FilterRules} class represents
subsets as lightweight \code{expression} and/or \code{function}
objects. Subsets can then be calculated when needed (on the fly). This
avoids copying and storing a large number of subsets. Although it
might take longer to frequently recalculate a subset, it often is a
relatively fast operation and the space savings tend to be more than
worth it when data is large.

Rules may be either expressions or functions. Evaluating an expression
or invoking a function should result in a logical vector. Expressions
are often more convenient, but functions (i.e. closures) are generally
safer and more powerful, because the user can specify the enclosing
environment. If a rule is an expression, it is evaluated inside the
\code{envir} argument to the \code{eval} method (see below). If a
function, it is invoked with \code{envir} as its only
argument. See examples.
\end{Details}
\begin{Section}{Accessor methods}
In the code snippets below, \code{x} is a \code{RangedData} object.

\describe{
\item[] \code{active(x)}: Get the logical vector of length
\code{length(x)}, where \code{TRUE} for an element indicates that
the corresponding rule in \code{x} is active (and inactive
otherwise). Note that \code{names(active(x))} is equal to
\code{names(x)}.

\item[] \code{active(x) <- value}: Replace the active state of the
filter rules. If \code{value} is a logical vector, it should be of
length \code{length(x)} and indicate which rules are
active. Otherwise, it can be either numeric or character vector, in which
case it sets the indicated rules (after dropping NA's) to active and
all others to inactive. See examples.
}
\end{Section}
\begin{Section}{Constructor}
\describe{
\item[] \code{FilterRules(exprs = list(), ..., active = TRUE)}:
Constructs a \code{FilterRules} with the rules given in the list
\code{exprs} or in \code{...}. The initial active state of the rules
is given by \code{active}, which is recycled as
necessary. Elements in \code{exprs} may be either character (parsed
into an expression), a language object (coerced to an expression), an
expression, or a function that takes at least one
argument. \strong{IMPORTANTLY}, all arguments in \code{...} are
\strong{\code{quote()}}'d and then coerced to an expression. So,
for example, character data is only parsed if it is a literal.
The names of the filters are taken from the names of
\code{exprs} and \code{...}, if given. Otherwise,
the character vectors take themselves as their name and the
others are deparsed (before any coercion). Thus, it is recommended
to always specify meaningful names. In any case, the names
are made valid and unique.

}
\end{Section}
\begin{Section}{Subsetting and Replacement}
In the code snippets below, \code{x} is a \code{FilterRules} object.

\describe{
\item[] \code{x[i]}: Subsets the filter rules using the
same interface as for \code{\LinkA{Sequence}{Sequence.Rdash.class}}.

\item[] \code{x[[i]]}: Extracts an expression or function via the same
interface as for \code{\LinkA{Sequence}{Sequence.Rdash.class}}.

\item[] \code{x[[i]] <- value}: The same interface as for
\code{\LinkA{Sequence}{Sequence.Rdash.class}}. The default active state for new
rules is \code{TRUE}.

}
\end{Section}
\begin{Section}{Combining}
In the code snippets below, \code{x} is a \code{FilterRules} object.

\describe{
\item[] \code{append(x, values, after = length(x))}: Appends the
\code{values} \code{FilterRules} instance onto \code{x} at the
index given by \code{after}.

\item[] \code{c(x, ..., recursive = FALSE)}: Concatenates the
\code{FilterRule} instances in \code{...} onto the end of \code{x}.

}
\end{Section}
\begin{Section}{Evaluating}
\describe{
\item[] \code{eval(expr, envir = parent.frame(),
        enclos = if (is.list(envir) || is.pairlist(envir))
        parent.frame() else baseenv())}: 
Evaluates a \code{FilterRules} instance (passed as the
\code{expr} argument). Expression rules are
evaluated in \code{envir}, while function rules are invoked with
\code{envir} as their only argument. The evaluation of a rule
should yield a logical vector. The results from the rule
evaluations are combined via the AND operation (i.e. \code{\&}) so
that a single logical vector is returned from \code{eval}.

}
\end{Section}
\begin{Author}\relax
Michael Lawrence
\end{Author}
\begin{SeeAlso}\relax
\code{\LinkA{rdapply}{rdapply}}, which accepts a \code{FilterRules} instance to
filter each space before invoking the user function.
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}
  ## constructing a FilterRules instance

  ## an empty set of filters
  filters <- FilterRules()
  
  ## as a simple character vector
  filts <- c("peaks", "promoters")
  filters <- FilterRules(filts)
  active(filters) # all TRUE

  ## with functions and expressions
  filts <- list(peaks = expression(peaks), promoters = expression(promoters),
                find_eboxes = function(rd) rep(FALSE, nrow(rd)))
  filters <- FilterRules(filts, active = FALSE)
  active(filters) # all FALSE

  ## direct, quoted args (character literal parsed)
  filters <- FilterRules(under_peaks = peaks, in_promoters = "promoters")
  filts <- list(under_peaks = expression(peaks),
                in_promoters = expression(promoters))

  ## specify both exprs and additional args
  filters <- FilterRules(filts, diffexp = de)

  filts <- c("peaks", "promoters", "introns")
  filters <- FilterRules(filts)

  ## set the active state directly
  
  active(filters) <- FALSE # all FALSE
  active(filters) <- TRUE # all TRUE
  active(filters) <- c(FALSE, FALSE, TRUE)
  active(filters)["promoters"] <- TRUE # use a filter name
  
  ## toggle the active state by name or index
  
  active(filters) <- c(NA, 2) # NA's are dropped
  active(filters) <- c("peaks", NA) 
\end{ExampleCode}
\end{Examples}

