@@ -2,14 +2,16 @@

 # TODO: Test against some of Bismark's other output files. May need a stricter

 #       and more accurate heuristic to avoid 'passing' bad files.

-# NOTE: Not using readr::count_fields() because it is very slow on large,

-#       compressed files. This is because it reads the entire file into memory

-#       as a raw vector regardless of the value of `n_max` (see

-#       https://github.com/tidyverse/readr/issues/610). But good old

-#       utils::read.delim() doesn't have this limitation!

+# TODO: Test for 'bismark_methylation_extractor' and 'bedGraph' formats

+#       (https://github.com/FelixKrueger/Bismark/tree/master/Docs#output-1)

 .guessBismarkFileType <- function(files, n_max = 10L) {

     guessed_file_types <- setNames(vector("character", length(files)), files)

     for (file in files) {

+        # NOTE: Not using readr::count_fields() because it is very slow on

+        #       large, compressed files. This is because it reads the entire

+        #       file into memory as a raw vector regardless of the value of

+        #       `n_max` (see https://github.com/tidyverse/readr/issues/610).

+        #       But good old utils::read.delim() doesn't have this limitation!

         x <- read.delim(

             file = file,

             header = FALSE,

@@ -53,8 +55,9 @@

                              ...) {

     col_spec <- match.arg(col_spec)

     file_type <- .guessBismarkFileType(file)

+    # TODO: Test for 'bismark_methylation_extractor' and 'bedGraph' formats,

+    #       and error out (they're not supported).

     stopifnot(S4Vectors:::isTRUEorFALSE(check))

-    # TODO: Read in seqnames as a factor?

     if (file_type == "cov") {

         col_names <- c("seqnames", "start", "end", "beta", "M", "U")

         if (col_spec == "BSseq") {

@@ -353,9 +356,7 @@

 # TODO: Support BPREDO?

 # TODO: Support passing a colData so that metadata is automatically added to

 #       samples?

-# TODO: Properly pass down verbose as subverbose to functions that take verbose

-#       argument.

-# NOTE: `...` are used to pass filepath, chunkdim, level, etc. to

+# TODO: Document that `...` are used to pass filepath, chunkdim, level, etc. to

 #       HDF5RealizationSink().

 # TODO: (long term) Formalise `...` by something analogous to the

 #       BiocParallelParam class (RealizationSinkParam) i.e. something that

@@ -368,15 +369,15 @@

 #       is used in conjunction with files without strand information.

 read.bismark <- function(files,

                          sampleNames = basename(files),

+                         loci = NULL,

                          rmZeroCov = FALSE,

                          strandCollapse = TRUE,

-                         fileType = c("cov", "oldBedGraph", "cytosineReport"),

-                         loci = NULL,

-                         mc.cores = 1,

                          verbose = TRUE,

                          BPPARAM = bpparam(),

                          BACKEND = getRealizationBackend(),

-                         ...) {

+                         ...,

+                         fileType = c("cov", "oldBedGraph", "cytosineReport"),

+                         mc.cores = 1) {

     # Argument checks ----------------------------------------------------------

     # Check for deprecated arguments and issue warning(s) if found.

@@ -557,32 +558,20 @@ read.bismark <- function(files,

 # TODOs ------------------------------------------------------------------------

-# TODO: The documentation needs a complete overhaul and checked against Bismark

-#       docs (e.g., the description of the .cov file is wrong)

 # TODO: Consolidate use of message()/cat()/etc.

 # TODO: Add function like minfi::read.metharray.sheet()?

 # TODO: Should BACKEND really be an argument of read.bismark(); see related

 #       issue on minfi repo https://github.com/hansenlab/minfi/issues/140

 # TODO: May receive warning "In read_tokens_(data, tokenizer, col_specs, col_names,  ... : length of NULL cannot be changed". This is fixed in devel version of

 #       readr (https://github.com/tidyverse/readr/issues/833)

-# TODO: Decide whether to preserve verbose argument of several functions.

-# TODO: Document that if 'loci' is supplied then only loci in it will be

-#       retained.

 # TODO: Think about naming scheme for functions. Try to have the function that

 #       is bpapply()-ed have a similar name to its parent.

 # TODO: Document internal functions for my own sanity. Also, some may be useful

 #       to users of bsseq (although I still won't export these for the time

 #       being).

-# TODO: Allow user to specify HDF5 file and have both M and Cov written to that

-#       file.

-# TODO: Helper function to obtain CpX loci from BSgenome as GRanges to pass as

-#       'gr' argument in read.bismark().

 # TODO: (long term) Current implementation requires that user can load at least

 #       one sample's worth of data into memory per worker. Could instead read

 #       chunks of data, write to sink, load next chunk, etc.

-# TODO: Add big note to documentation that .cov file does not contain strand

-#       information, which means strandCollapse can't be used (unless 'gr' is

-#       supplied or one of the other files is a cytosineReport file).

 # TODO: Document that if 'gr' is NULL and any 'files' (especially the first

 #       file) are .cov files, then any loci present in the .cov files will have

 #       their strand set to *. If you are mixing and matching .cov and

@@ -1,4 +1,5 @@

 \name{read.bismark}

+% TODO: alias required?

 \alias{read.bismark}

 \title{

   Parsing output from the Bismark alignment suite.

@@ -7,125 +8,244 @@

   Parsing output from the Bismark alignment suite.

 }

 \usage{read.bismark(files,

-             sampleNames,

+             sampleNames = basename(files),

+             loci = NULL,

              rmZeroCov = FALSE,

              strandCollapse = TRUE,

-             fileType = c("cov", "oldBedGraph", "cytosineReport"),

-             mc.cores = 1,

              verbose = TRUE,

-             BACKEND = NULL)

+             BPPARAM = bpparam(),

+             BACKEND = getRealizationBackend(),

+             ...,

+             fileType = c("cov", "oldBedGraph", "cytosineReport"),

+             mc.cores = 1)

 }

 \arguments{

-  \item{files}{Input files. Each sample is in a different file. Input

-    files are created by running Bismark's methylation extractor; see Note for

-    details.}

-  \item{sampleNames}{sample names, based on the order of \code{files}.}

-  \item{rmZeroCov}{Should methylation loci that have zero coverage in

-    all samples be removed. This will result in a much smaller object if

-    the data originates from (targeted) capture bisulfite sequencing.}

-  \item{strandCollapse}{Should strand-symmetric methylation loci, e.g., CpGs,

-    be collapsed across strands. This option is only available if

-    \code{fileType = "cytosineReport"} since the other file types do not

-    contain the necessary strand information.}

-  \item{fileType}{The format of the input file; see Note for details.}

-  \item{mc.cores}{The number of cores used.  Note that setting

-    \code{mc.cores} to a value greater than 1 is not  supported on MS

-    Windows, see the help page for \code{mclapply}.}

-  \item{verbose}{Make the function verbose.}

-  \item{BACKEND}{The backend used for the 'M' and 'Cov' matrices. The default,

-  \code{NULL}, corresponds to using \link[base]{matrix} objects. See

-    \code{?DelayedArray::\link[DelayedArray]{setRealizationBackend}} for

-    alternative backends.}

+  \item{files}{The path to the files created by running Bismark's methylation

+    extractor, one sample per file.

+    Files ending in \code{.gz}, \code{.bz2}, \code{.xz}, or \code{.zip} will be automatically uncompressed.

+    We strongly recommend you use the 'genome wide cytosine report' output files.

+    See section 'File formats' for further details.}

+  \item{sampleNames}{A character vector of sample names, based on the order of \code{files}.}

+  \item{loci}{\code{NULL} (default) or a \linkS4class{GenomicRanges} instance

+    containing methylation loci (all with width equal to 1).

+    If \code{loci = NULL}, then \code{read.bismark()} will perform a first pass over the Bismark file to identify candidate loci.

+    If \code{loci} is a \linkS4class{GenomicRanges} instance, then these form the candidate loci.

+    In either case, the candidate loci will be filtered if

+    \code{rmZeroCov = TRUE} and collapsed if \code{strandCollapse = TRUE} to form the final set of methylation loci that form the \code{\link[SummarizedExperiment]{rowRanges}} of the returned \linkS4class{BSseq} object.

+    See section 'Efficient use of \code{read.bismark()}' for further details.}

+  \item{rmZeroCov}{A \code{logical(1)} indicating whether methylation loci that

+    have zero coverage in all samples be removed.

+    For several reasons, the default \code{rmZeroCov = FALSE} is recommended even in cases where you ultimately want to remove such loci.

+    See section 'Efficient use of \code{read.bismark()}' for further details.}

+  \item{strandCollapse}{A \code{logical(1)} indicating whether strand-symmetric

+    methylation loci (i.e. CpGs) should be collapsed across strands.

+    This is only applicable for stranded methylation loci, e.g., loci extracted

+    from 'genome wide cytosine reports' (see section 'File formats' for further details).}

+  \item{verbose}{A \code{logical(1)} indicating whether progress messages

+    should be printed (default \code{TRUE}).}

+\item{BPPARAM}{An optional \linkS4class{BiocParallelParam} instance

+    determining the parallel back-end to be used during evaluation.

+    Currently supported are \linkS4class{SerialParam} (Unix, Mac, Windows),

+    \linkS4class{MulticoreParam} (Unix and Mac), \linkS4class{SnowParam}

+    (Unix, Mac, and Windows, limited to single-machine clusters), and

+    \linkS4class{BatchJobsParam} (Unix, Mac, Windows, only with the in-memory

+    realization backend).

+    See sections 'Parallelization and progress  monitoring' and 'Realization backends' for further details.}

+  \item{BACKEND}{\code{NULL} or a single string specifying the name of the

+    realization backend.

+    When the backend is set to \code{NULL}, the \code{M} and \code{Cov} assays

+    are realized in memory as ordinary matrices, otherwise these are realized with the given \code{BACKEND}.

+    See section 'Realization backends' for further details.}

+  \item{...}{Additional arguments passed to the \linkS4class{RealizationSink}

+    constructor.

+    See section 'Realization backends' for further details.}

+  \item{fileType}{\strong{Deprecated}.

+    The format of each file is now automatically detected using the internal function \code{bsseq:::.guessBismarkFileType()}.}

+  \item{mc.cores}{\strong{Deprecated}.

+    See section 'Parallelization and progress monitoring' for further details.}

 }

-\note{

-  Input files can either be gzipped or not.

-

-  The user must specify the relevant file format via the \code{fileType}

-  argument. The format of the output of the Bismark alignment suite will depend

-  on the version of Bismark and on various user-specified options. Please

-  consult the Bismark documentation and the Bismark RELEASE NOTES

-  (\url{http://www.bioinformatics.bbsrc.ac.uk/projects/bismark/RELEASE_NOTES.txt})

-  for the definitive list of changes between versions. When possible, it is

-  strongly recommended that you use the most recent version of Bismark.

-

-  The "\code{cov}" and "\code{oldBedGraph}" formats both have six columns

-  ("\code{chromosome}", "\code{position}", "\code{strand}",

-  "\code{methylation percentage}", "\code{count methylated}",

-  "\code{count unmethylated}"). If you are using a recent version of Bismark

-  (\code{v>=0.10.0}) then the standard file extension for this file is

-  "\code{.cov}". If, however, you are using an older version of Bismark

-  (\code{v<0.10.0}) then the file extension will be "\code{.bedGraph}". Please

-  note that the "\code{.bedGraph}" file created in recent versions of Bismark

-  (\code{v>=0.10.0}) is \strong{not} suitable for analysis with bsseq because

-  it only contains the "\code{methylation percentage}" and not

-  "\code{count methylated}" nor "\code{count unmethylated}".

-

-  The "\code{cytosineReport}" format has seven columns

-  ("\code{chromosome}", "\code{position}", "\code{strand}",

-  "\code{count methylated}", "\code{count unmethylated}", "\code{C-context}",

-  "\code{trinucleotide context}").

-  There is no standard file extension for this file. The "\code{C-context}" and

-  "\code{trinucleotide context}" columns are not currently used by bsseq.

-

-  The following is a list of some issues to be aware of when using

-  output from Bismark's methylation extractor:

+

+\section{Efficient use of \code{read.bismark()}}{

+  We recommend the following to achieve fast and efficient importing of Bismark files:

   \itemize{

-    \item The program to extract methylation counts was named

-    \code{methylation_extractor} in older versions of Bismark (\code{v<0.8.0})

-    and re-named \code{bismark_methylation_extractor} in recent versions of

-    Bismark (\code{v>=0.8.0}). Furthermore, very old versions of Bismark

-    (\code{v<0.7.7}) required that user run a separate script (called

-    something like \code{genome_methylation_bismark2bedGraph}) to create the

-    six-column "\code{cov}"/"\code{oldBedGraph}" file.

-    \item The \code{--counts} and \code{--bedGraph} arguments must be supplied

-    to \code{methylation_extractor}/\code{bismark_methylation_extractor} in

-    order to use the output with \code{bsseq::read.bismark()}.

-    \item The genomic co-ordinates of the Bismark output file may be zero-based

-    or one-based depending on whether the \code{--zero_based} argument is used.

-    Furthermore, the default co-ordinate system varies by version of Bismark.

-    bsseq makes no assumptions about the basis of the genomic co-ordinates and

-    it is left to the user to ensure that the appropriate basis is used in the

-    analysis of their data. Since Bioconductor packages and

-    \code{\linkS4class{GRanges}} use one-based co-ordinates, it

-    is recommended that your Bismark files are also one-based.

+    \item Specify the set of methylation loci via the \code{loci} argument.

+    \item Leave \code{rmZeroCov = FALSE}.

+    \item Use a \code{BPPARAM} with a large number of workers (cores).

+    \item Use \code{BACKEND = "HDF5Array"}.

+  }

+

+  Each point is discussed below.

+  \subsection{Specifying \code{loci}}{

+    Specifying the set of methylation loci via the \code{loci} argument means that \code{read.bismark()} does not need to first parse all \code{files} to identify the set of candidate loci.

+    Provided that \code{rmZeroCov = FALSE}, this means that each file is only read once.

+    This may be a considerable saving when there are a large number of \code{files}.

+

+    \strong{If you are unsure whether the below-described shortcuts apply to your data, leave \code{loci = NULL} and let \code{read.bismark()} identify the set of candidate loci from \code{files}.}

+

+    If all \code{files} are 'genome wide cytosine reports' for samples aligned to the same reference genome, then all \code{files} contain the exact same set of methylation loci.

+    In this case, you may wish to first construct \code{loci} using the internal function \code{bsseq:::.readBismarkAsFWGRanges()} applied to a single file, e.g., \code{loci = bsseq:::.readBismarkAsFWGRanges(files[1], rmZeroCov, strandCollapse)}.

+

+    % TODO: Uncomment once findCytosines is exported and documented.

+    % Alternatively, you may wish to use the \code{\link{findCytosines}()} function to construct all methylation loci of interest (e.g., all CpGs) in your reference genome and then pass this via the \code{loci} argument.

+  }

+

+  \subsection{Leaving \code{rmZeroCov = FALSE}}{

+    If you set \code{rmZeroCov = TRUE}, then \code{read.bismark()} must first parse all the \code{files} to identify which loci have zero coverage in all samples and then filter these out from the set of candidate loci.

+    \strong{This will happen regardless of whether \code{loci} is \code{NULL} or is supplied as a \linkS4class{GenomicRanges} of candidate loci.}

+

+    Furthermore, any coverage-based filtering of methylation loci is best left until you have constructed your final \linkS4class{BSseq} object.

+    In our experience, the final \linkS4class{BSseq} object is often the product of combining multiple \linkS4class{BSseq} objects, each constructed with a separate call to \code{read.bismark()}.

+    In such cases, it is premature to use \code{rmZeroCov = TRUE} when running each \code{read.bismark()} and combining these objects will regretably often lead to an inefficiently constructed final \linkS4class{BSseq} object.

   }

+

+  \subsection{Using a \code{BPPARAM} with a large number of workers (cores)}{

+    Each file can be processed on its own, so you can process in parallel as many files as you have workers. We have good experience using as many as 40 cores via \code{BPPARAM = MulticoreParam(workers = 40)}.}

+

+  \subsection{Using \code{BACKEND = "HDF5Array"}}{

+    By using the HDF5Array realization backend from \pkg{HDF5Array}, we reduce the amount of data that is kept in-memory at any one time.

+    Once each file is parsed, the data are written to the HDF5 file and are no longer needed in-memory.

+    When combined with multiple workers (cores), this means that each file will only need to read and retain in-memory 1 sample's worth of data at a time.

+

+    Conversely, if you opt for all data to be in-memory (via \code{BACKEND = NULL}), then each worker will pass each file's data back to the main process and memory usage will steadily accumulate to often unreasonable levels.

+    }

 }

+

+\section{File formats}{

+  The format of each file is automatically detected using the internal function \code{bsseq:::.guessBismarkFileType()}.

+  Files ending in \code{.gz}, \code{.bz2}, \code{.xz}, or \code{.zip} will be automatically uncompressed.

+  \subsection{Supported file formats}{

+     We strongly recommend that you use the 'genome wide cytosine report' output format

+     (\url{https://github.com/FelixKrueger/Bismark/tree/master/Docs#the-genome-wide-cytosine-report-optional-is-tab-delimited-in-the-following-format-1-based-coords}) as this includes trand information for each locus.

+     The 'coverage' output format (\url{https://github.com/FelixKrueger/Bismark/tree/master/Docs#the-coverage-output-looks-like-this-tab-delimited-1-based-genomic-coords}) is also supported, although all loci from these files will have their \code{\link[BiocGenerics]{strand}} set to \code{*} in the returned \linkS4class{BSseq} object because this file format does not include strand information.

+  }

+

+  \subsection{Unsupported file formats}{

+     Neither the 'bedGraph' output format (\url{https://github.com/FelixKrueger/Bismark/tree/master/Docs#the-bedgraph-output-optional-looks-like-this-tab-delimited-0-based-start-1-based-end-coords}) nor the 'bismark_methylation_extractor' output format (\url{https://github.com/FelixKrueger/Bismark/tree/master/Docs#the-bismark_methylation_extractor-output-is-in-the-form-tab-delimited-1-based-coords}) are supported.

+     The former does not include the required counts of methylated and unmethylated reads hile the is an intermediate file containing read-level, rather than locus-level, data on methylation.

+  }

+  \subsection{One-based vs. zero-based genomic co-ordinates}{

+    The genomic co-ordinates of the Bismark output files may be zero-based or one-based depending on whether the \code{--zero_based} argument was used when running Bismark's methylation extractor.

+    Furthermore, the default co-ordinate counting system varies by version of Bismark.

+    \pkg{bsseq} makes no assumptions about the basis of the genomic co-ordinates and it is left to the user to ensure that the appropriate basis is used in the analysis of their data.

+

+    Since Bioconductor packages typically use one-based co-ordinates, we strongly recommend that your Bismark files are also one-based.

+  }

+}

+

+\section{Realization backends}{

+  The \code{read.bismark()} function creates a \linkS4class{BSseq} object with two assays, \code{M} and \code{Cov}.

+  The choice of \emph{realization backend} controls whether these assays are stored in-memory as an ordinary \link[base]{matrix} or on-disk as a \linkS4class{HDF5Array}, for example.

+  The choice of realization backend is controlled by the \code{BACKEND} argument, which defaults to the current value of \code{DelayedArray::\link[DelayedArray]{getRealizationBackend()}}.

+

+  \code{read.bismark()} supports the following realization backends:

+

+  \itemize{

+    \item \code{NULL} (in-memory): This stores each new assay in-memory using an ordinary \link[base]{matrix}.

+    \item \code{HDF5Array} (on-disk): This stores each new assay on-disk in a HDF5 file using an \linkS4class{HDF5Matrix} from \pkg{HDF5Array}.

+  }

+

+  Please note that certain combinations of realization backend and parallelization backend are currently not supported.

+  For example, the \linkS4class{HDF5Array} realization backend is currently only compatible when used with a single-machine parallelization backend (i.e. it is not compatible

+  with a \linkS4class{SnowParam} that specifies an \emph{ad hoc} cluster of

+  \strong{multiple} machines).

+  % TODO: Test this

+  \code{BSmooth()} will issue an error when given such incompatible realization and parallelization backends.

+

+  Additional arguments related to the realization backend can be passed via the \code{...} argument.

+  These arguments must be named and are passed to the relevant \linkS4class{RealizationSink} constructor.

+  For example, the \code{...} argument can be used to specify the path to the HDF5 file to be

+  used by \code{BSmooth()}.

+  Please see the examples at the bottom of the page.

+}

+

+\section{Parallelization and progress monitoring}{

+  \code{read.bismark()} now uses the \pkg{BiocParallel} package to implement

+  parallelization. This brings some notable improvements:

+

+  \itemize{

+    \item Imported files can now be written directly to an on-disk

+      realization backend by the worker. This dramatically reduces memory

+      usage compared to previous versions of \pkg{bsseq} that required all

+      results be retained in-memory.

+    \item Parallelization is now supported on Windows through the use of a

+    \linkS4class{SnowParam} object as the value of \code{BPPARAM}.

+    % TODO: Uncomment when/if implemented.

+    %\item Improved error handling makes it possible to gracefully resume

+    %\code{read.bismark()} jobs that encountered errors by re-doing only the necessary

+    %tasks.

+    \item Detailed and extensive job logging facilities.

+  }

+

+  All parallelization options are controlled via the \code{BPPARAM} argument.

+  In general, we recommend that users combine multicore (single-machine)

+  parallelization with an on-disk realization backend (see section,

+  'Realization backend'). For Unix and Mac users, this means using

+  a \linkS4class{MulticoreParam}. For Windows users, this means using a

+  single-machine \linkS4class{SnowParam}. Please consult the \pkg{BiocParallel}

+  documentation to take full advantage of the more advanced features.

+

+  \subsection{Deprecated arguments}{

+    \code{mc.cores} is deprecated and will be removed in subsequent releases of \pkg{bsseq}.

+    This argument was necessary when \code{read.bismark()} used the \pkg{parallel} package to implement parallelization, but this functionality is superseded by the aforementioned use of \pkg{BiocParallel}.

+    We recommend that users who previously relied on these arguments switch to \code{BPPARAM = MulticoreParam(workers = mc.cores, progressbar = TRUE)}.

+  }

+

+  \subsection{Progress monitoring}{

+    A useful feature of \pkg{BiocParallel} are progress bars to monitor the

+    status of long-running jobs, such as \code{BSmooth()}. Progress bars are

+    controlled via the \code{progressbar} argument in the

+    \linkS4class{BiocParallelParam} constructor. Progress bars replace the

+    use of the deprecated \code{verbose} argument to print out information on

+    the status of \code{BSmooth()}.

+

+    \pkg{BiocParallel} also supports extensive and detailed logging facilities.

+    Please consult the \pkg{BiocParallel} documentation to take full advantage

+    these advanced features.

+  }

+}

+

 \value{

-  An object of class \code{\link{BSseq}}.

+  A \linkS4class{BSseq} object.

 }

 \seealso{

-  \code{\link{read.bsmooth}} for parsing output from the BSmooth

-  alignment suite. \code{\link{read.umtab}} for parsing legacy (old)

-  formats from the  BSmooth alignment suite.

-  \code{\link{collapseBSseq}} for collapse (merging or summing) the

-  data in two different directories.

+  \code{\link{read.bsmooth}()} for parsing output from the BSmooth

+  alignment suite.

+  \code{\link{read.umtab}()} for parsing legacy (old) formats from the BSmooth alignment suite.

+  \code{\link{collapseBSseq}()} for collapsing (aggregating) data from sample's with multiple Bismark methylation extractor files (e.g., technical replicates).

 }

 \examples{

+  # Run read.bismark() on a single sample to construct a matrix-backed BSseq

+  # object.

   infile <- system.file("extdata/test_data.fastq_bismark.bismark.cov.gz",

                         package = 'bsseq')

-  bismarkBSseq <- read.bismark(files = infile,

-                               sampleNames = "test_data",

-                               rmZeroCov = FALSE,

-                               strandCollapse = FALSE,

-                               fileType = "cov",

-                               verbose = TRUE)

-  bismarkBSseq

-

-  #-----------------------------------------------------------------------------

-  # An example constructing a HDF5Array-backed BSseq object

-  #

-  library(HDF5Array)

-  # See ?DelayedArray::setRealizationBackend for details

-  hdf5_bismarkBSseq <- read.bismark(files = infile,

-                                    sampleNames = "test_data",

-                                    rmZeroCov = FALSE,

-                                    strandCollapse = FALSE,

-                                    fileType = "cov",

-                                    verbose = TRUE,

-                                    BACKEND = "HDF5Array")

+  bsseq <- read.bismark(files = infile,

+                        sampleNames = "test_data",

+                        rmZeroCov = FALSE,

+                        strandCollapse = FALSE,

+                        verbose = TRUE)

+  # This is a matrix-backed BSseq object.

+  sapply(assays(bsseq, withDimnames = FALSE), class)

+  bsseq

+

+  \dontrun{

+  # Run read.bismark() on a single sample to construct a HDF5Array-backed BSseq

+  # object (with data written to the file 'read.bismark_example.h5')

+  bsseq <- read.bismark(files = infile,

+                        sampleNames = "test_data",

+                        rmZeroCov = FALSE,

+                        strandCollapse = FALSE,

+                        verbose = TRUE,

+                        BACKEND = "HDF5Array",

+                        filepath = "read.bismark_example.h5")

+  # This is a HDF5Array-backed BSseq object.

+  sapply(assays(bsseq, withDimnames = FALSE), class)

+  # The 'M' and 'Cov' assays are in the HDF5 file 'read.bismark_example.h5' (in

+  # the current working directory).

+  sapply(assays(bsseq, withDimnames = FALSE), path)

+  }

 }

 \author{