@@ -9,10 +9,10 @@ Description: GSNAP and GMAP are a pair of tools to align short-read

         methods to work with GMAP and GSNAP from within R. In addition,

         it provides methods to tally alignment results on a

         per-nucleotide basis using the bam_tally tool.

-Version: 1.13.3

+Version: 1.13.4

 Depends: R (>= 2.15.0), methods, GenomeInfoDb (>= 1.1.3),

         GenomicRanges (>= 1.17.12)

-Imports: S4Vectors, IRanges, Rsamtools (>= 1.17.8), rtracklayer (>= 1.25.5),

+Imports: S4Vectors, IRanges, Rsamtools (>= 1.17.8), rtracklayer (>= 1.31.2),

         GenomicFeatures (>= 1.17.13), Biostrings, VariantAnnotation (>= 1.11.4),

         tools, Biobase, BSgenome, GenomicAlignments (>= 1.1.9), BiocParallel

 Suggests: RUnit, BSgenome.Dmelanogaster.UCSC.dm3,

@@ -21,7 +21,9 @@ Suggests: RUnit, BSgenome.Dmelanogaster.UCSC.dm3,

         LungCancerLines

 Collate: GmapBamReader-class.R GmapGenomeDirectory-class.R

         GmapGenome-class.R GmapSnpDirectory-class.R GmapSnps-class.R

-        GsnapParam-class.R GsnapOutput-class.R atoiindex-command.R

+        GmapParam-class.R GsnapParam-class.R

+        GsnapOutput-class.R GmapOutput-class.R

+        atoiindex-command.R

         BamTallyParam-class.R bam_tally-command.R cmetindex-command.R

         get-genome-command.R gmap-command.R gmap_build-command.R

         gsnap-command.R iit-format.R iit_store-command.R info.R

@@ -18,7 +18,7 @@ importMethodsFrom(GenomicRanges, seqnames, strand)

 importMethodsFrom(Rsamtools, asBam)

 importClassesFrom(GenomicFeatures, TxDb)

 importFrom(GenomicFeatures, transcripts, exons)

-importClassesFrom(rtracklayer, RTLFile, FastaFile)

+importClassesFrom(rtracklayer, RTLFile, FastaFile, RTLFileList)

 importFrom(rtracklayer, "referenceSequence<-", import, export, FastaFile)

 importMethodsFrom(rtracklayer, export)

 importFrom(VariantAnnotation, readVcf, ScanVcfParam, fixed, VRanges, ref, alt,

@@ -32,10 +32,14 @@ importMethodsFrom(GenomicAlignments, qwidth)

 export(bam_tally, GmapGenome, GmapGenomeDirectory, GsnapParam,

        directory, BamTallyParam, makeGmapGenomePackage, GsnapOutput,

-       GmapSnps, GmapSnpDirectory, TP53Genome, TP53Which, variantSummary)

+       GmapSnps, GmapSnpDirectory, TP53Genome, TP53Which, variantSummary,

+       GmapParam)

 exportClasses(GmapGenome, GmapGenomeDirectory, GmapSnpDirectory,

-              GsnapOutput, GmapSnps, BamTallyParam, GsnapParam)

+              GsnapOutput, GmapSnps, BamTallyParam, GsnapParam, GmapParam,

+              GmapAlignerParam)

 exportMethods(bamPaths, path, genome, seqinfo, gsnap, "snps<-",

-              "spliceSites<-", getSeq)

+              "spliceSites<-", getSeq, gmap)

+

+S3method(as.list, GmapAlignerParam)

new file mode 100644

@@ -0,0 +1,98 @@

+### =========================================================================

+### GmapOutput class

+### -------------------------------------------------------------------------

+###

+### Stores a path to a GMAP output directory. This is based on the

+### assumption that the alignments from a sample will land in a

+### unique directory.

+###

+

+setClassUnion("GmapParamORNULL", c("GmapParam", "NULL"))

+setIs("GmapParamORNULL", "GmapAlignerParamORNULL")

+

+.valid_GmapOutput <- function(object) {

+    if (length(paths(object)) == 0L)

+        paste0("No GSNAP output at '", object@path, "'")

+}

+

+setClass("GmapOutput",

+         representation(path = "character",

+                        param = "GmapParamORNULL",

+                        version = "POSIXltORNULL"),

+         contains="GmapAlignerOutput",

+         validity = .valid_GmapOutput)

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Accessors

+###

+

+setMethod("alignmentCategories", "GmapOutput", function(x) {

+              c("uniq", "mult", "chimera", "nomapping")

+          })

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Constructor

+###

+

+GmapOutput <- function(path, param = NULL, version = NULL) {

+    newGmapAlignerOutput("GmapOutput", path, param, version)

+}

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Coercion

+###

+

+formatToExt <- function(x) {

+    switch(x,

+           gff3_gene=, gff3_match_cdna=, gff3_match_est="gff3",

+           sampe=, samse="sam",

+           psl="psl", splicesites="splicesites", introns="introns",

+           map_exons="iit", map_ranges="iit", coords="coords")

+}

+

+setAs("GmapOutput", "RTLFileList", function(from) {

+          as(lapply(paths(from), FileForFormat, formatToExt(from@param@format)),

+             "List")

+      })

+

+setAs("GmapOutput", "RTLFile", function(from) {

+          p <- paths(from)

+          if (length(p) == 0L) {

+              stop("no output files at: ", path(from))

+          }

+          FileForFormat(p[1L], formatToExt(from@param@format))

+      })

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Utilities

+###

+

+setMethod("import", c("GmapOutput", "missing", "missing"),

+          function(con, format, text, ...) {

+              if (con@param@format %in% c("samse", "sampe")) {

+                  f <- as(con, "BamFile")

+              } else {

+                  f <- as(con, "RTLFile")

+              }

+              ans <- import(f, ...)

+              seqinfo(ans) <- seqinfo(con@param@genome)

+              ans

+          })

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### List class

+###

+

+setClass("GmapOutputList",

+         prototype = prototype(elementType = "GmapOutput"),

+         contains = "GmapAlignerOutputList")

+

+setClass("SimpleGmapOutputList",

+         contains = c("GmapOutputList", "SimpleList"))

+

+GmapOutputList <- function(...) {

+    args <- list(...)

+    if (length(args) == 1 && is.list(args[[1]])) 

+        args <- args[[1]]

+    S4Vectors:::new_SimpleList_from_list("SimpleGmapOutputList", args)

+}

new file mode 100644

@@ -0,0 +1,60 @@

+### =========================================================================

+### GmapParam class

+### -------------------------------------------------------------------------

+###

+### High-level interface to gmap.

+###

+

+setClassUnion("GmapSnpsORNULL", c("GmapSnps", "NULL"))

+

+setClass("GmapAlignerParam",

+         representation(genome = "GmapGenome",

+                        part = "characterORNULL",

+                        batch = "character",

+                        snps = "GmapSnpsORNULL",

+                        mode = "character",

+                        nthreads = "integer",

+                        npaths = "integer",

+                        quiet_if_excessive = "logical",

+                        nofails = "logical", 

+                        split_output = "logical",

+                        extra = "list"))

+

+setClass("GmapParam",

+         representation(suboptimal_score = "integer",

+                        splicing = "logical",

+                        format = "character"),

+         contains="GmapAlignerParam")

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Constructor

+###

+

+GmapParam <- function(genome, unique_only = FALSE,

+                      suboptimal_score = 0L, mode = "standard",

+                      snps = NULL,

+                      npaths = if (unique_only) 1L else 100L,

+                      quiet_if_excessive = unique_only, nofails = unique_only,

+                      split_output = !unique_only,

+                      splicing = TRUE, 

+                      nthreads = 1L, part = NULL, batch = "2",

+                      format = c("gff3_gene", "gff3_match_cdna",

+                          "gff3_match_est", "sampe", "samse", "psl",

+                          "splicesites", "introns",

+                          "map_exons", "map_ranges", "coords"),

+                      ...)

+{

+    format <- match.arg(format)

+    newGmapAlignerParam("GmapParam", genome, snps)

+}

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Coercion

+###

+

+setAs("GmapParam", "list", function(from) {

+          to <- GmapAlignerParam_asList(from)

+          to$nosplicing <- !to$splicing

+          to$splicing <- NULL

+          to

+      })

@@ -9,35 +9,46 @@

 setClassUnion("POSIXltORNULL", c("POSIXlt", "NULL"))

-setClassUnion("GsnapParamORNULL", c("GsnapParam", "NULL"))

-

 .valid_GsnapOutput <- function(object) {

   if (length(samPaths(object)) == 0L && length(bamPaths(object)) == 0L)

     paste0("No GSNAP output at '", object@path, "'")

 }

-setClass("GsnapOutput",

+setClassUnion("GmapAlignerParamORNULL", c("GmapAlignerParam", "NULL"))

+

+setClassUnion("GsnapParamORNULL", c("GsnapParam", "NULL"))

+setIs("GsnapParamORNULL", "GmapAlignerParamORNULL")

+

+setClass("GmapAlignerOutput",

          representation(path = "character",

-                        param = "GsnapParamORNULL",

-                        version = "POSIXltORNULL"),

+                        param = "GmapAlignerParamORNULL",

+                        version = "POSIXltORNULL"))

+         

+setClass("GsnapOutput",

+         representation(param = "GsnapParamORNULL"),

+         contains="GmapAlignerOutput",

          validity = .valid_GsnapOutput)

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

 ### Accessors

 ###

-setMethod("path", "GsnapOutput", function(object) object@path)

+setMethod("path", "GmapAlignerOutput", function(object) object@path)

+

+setGeneric("alignmentCategories",

+           function(x) standardGeneric("alignmentCategories"))

-## should contain any category ever known to be used by gsnap

-.ALIGNMENT_CATEGORIES <- c("concordant_uniq", "concordant_mult",

-                           "concordant_transloc", "paired_mult",

-                           "paired_uniq_inv", "paired_uniq_long",

-                           "paired_uniq_scr", "unpaired_uniq", "unpaired_mult",

-                           "unpaired_transloc",  "halfmapping_uniq",

-                           "halfmapping_mult", "halfmapping_transloc",

-                           "nomapping", "concordant_circular",

-                           "halfmapping_circular", "paired_uniq_circular",

-                           "unpaired_circular")

+setMethod("alignmentCategories", "GsnapOutput", function(x) {

+              c("concordant_uniq", "concordant_mult",

+                "concordant_transloc", "paired_mult",

+                "paired_uniq_inv", "paired_uniq_long",

+                "paired_uniq_scr", "unpaired_uniq", "unpaired_mult",

+                "unpaired_transloc",  "halfmapping_uniq",

+                "halfmapping_mult", "halfmapping_transloc",

+                "nomapping", "concordant_circular",

+                "halfmapping_circular", "paired_uniq_circular",

+                "unpaired_circular")

+          })

 ### Q: How to handle the single BAM output case? We would still want a

 ### formal object, with a version, parameters, etc. If 'path' is a

@@ -53,31 +64,38 @@ is_dir <- function(x) {

 setGeneric("bamPath", function(x) standardGeneric("bamPath"))

-setMethod("bamPath", "GsnapOutput", function(x) {

-  paths <- bamPaths(x)

-  if (length(paths) > 1) # maybe this should be the analysis BAM if it exists?

-    paths <- paths["concordant_uniq"]

-  paths

-})

+setMethod("bamPath", "GmapAlignerOutput", function(x) {

+              paths <- bamPaths(x)

+              if (length(paths) > 1L)

+                  paths <- paths[alignmentCategories(x)[1L]]

+              paths

+          })

 ## file_ext does not allow '_'

 file_ext2 <- function(x) {

   gsub(".*\\.", "", x)

 }

+paths <- function(x) {

+    if (!is_dir(x)) {

+        return(path(x))

+    }

+    paths <- list_files_with_exts(path(x), alignmentCategories(x),

+                                  full.names = TRUE)

+    names(paths) <- file_ext2(paths)

+    paths[alignmentCategories(x)]

+}

+

 samPaths <- function(x) {

   if (!is_dir(x)) {

     if (file_ext(path(x)) == "sam")

       return(path(x))

     return(character())

   }

-  paths <- list_files_with_exts(path(x), .ALIGNMENT_CATEGORIES,

-                                full.names = TRUE)

-  names(paths) <- file_ext2(paths)

-  paths

+  paths(x)

 }

-setMethod("bamPaths", "GsnapOutput", function(x) {

+setMethod("bamPaths", "GmapAlignerOutput", function(x) {

   if (!is_dir(x)) {

     if (file_ext(path(x)) == "bam")

       return(path(x))

@@ -85,7 +103,7 @@ setMethod("bamPaths", "GsnapOutput", function(x) {

   }

   paths <- list_files_with_exts(path(x), "bam", full.names = TRUE)

   names(paths) <- file_ext2(file_path_sans_ext(paths))

-  paths <- paths[names(paths) %in% .ALIGNMENT_CATEGORIES]

+  paths <- paths[names(paths) %in% alignmentCategories(x)]

   paths

 })

@@ -93,29 +111,31 @@ setMethod("bamPaths", "GsnapOutput", function(x) {

 ### Constructor

 ###

+newGmapAlignerOutput <- function(Class, path, param = NULL, version = NULL) {

+    if (!is.character(path) || any(is.na(path)))

+        stop("'path' must be a character vector without any NA's")

+    if (!is(version, "POSIXltORNULL")) {

+        if (is.character(version))

+            version <- parseGsnapVersion(version)

+        else stop("'version' must be a version string, POSIXlt object or NULL")

+    }

+    path <- file_path_as_absolute(path)

+    new(Class, path = path, version = version, param = param)

+}

+

 GsnapOutput <- function(path, param = NULL, version = NULL) {

-  if (!is.character(path) || any(is.na(path)))

-    stop("'path' must be a character vector without any NA's")

-  if (!is(version, "POSIXltORNULL")) {

-    if (is.character(version))

-      version <- parseGsnapVersion(version)

-    else stop("'version' must be a version string, POSIXlt object or NULL")

-  }

-  if (!is(param, "GsnapParamORNULL"))

-    stop("'param' must be a GsnapParam object or NULL")

-  path <- file_path_as_absolute(path)

-  new("GsnapOutput", path = path, version = version, param = param)

+  newGmapAlignerOutput("GsnapOutput", path, param, version)

 }

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

 ### Coercion

 ###

-setAs("GsnapOutput", "BamFileList", function(from) {

+setAs("GmapAlignerOutput", "BamFileList", function(from) {

   BamFileList(bamPaths(from))

 })

-setAs("GsnapOutput", "BamFile", function(from) {

+setAs("GmapAlignerOutput", "BamFile", function(from) {

   BamFile(bamPath(from))

 })

@@ -123,19 +143,19 @@ setAs("GsnapOutput", "BamFile", function(from) {

 ### Utilities

 ###

-setMethod("merge", c("GsnapOutput", "GsnapOutput"), function(x, y) {

+setMethod("merge", c("GmapAlignerOutput", "GmapAlignerOutput"), function(x, y) {

 ### TODO: get Cory's lane merging code for BAMs in here

 })

 setGeneric("consolidate", function(x, ...) standardGeneric("consolidate"))

-setMethod("consolidate", "GsnapOutput", function(x) {

+setMethod("consolidate", "GmapAlignerOutput", function(x) {

 ### TODO: this should produce the pipeline's analyzed BAM

   x

 })

 ##converts all gsnap SAM files to BAM files and creates the .bai index files

-setMethod("asBam", "GsnapOutput",

+setMethod("asBam", "GmapAlignerOutput",

           function(file) {

             ## the input is not a file. It is a GsnapOutput,

             ## but param name is enforced

@@ -155,6 +175,11 @@ setMethod("asBam", "GsnapOutput",

             file

 })

+setMethod("import", c("GsnapOutput", "missing", "missing"),

+          function(con, format, text, ...) {

+              import(as(con, "BamFile"), ...)

+          })

+

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

 ### List class

 ###

@@ -167,9 +192,13 @@ setMethod("asBam", "GsnapOutput",

 ### character vectors. Would we vectorize the version or not? It makes

 ### sense to have an object that represents a single run of gsnap.

+setClass("GmapAlignerOutputList",

+         prototype = prototype(elementType = "GmapAlignerOutput"),

+         contains = "List")

+

 setClass("GsnapOutputList",

          prototype = prototype(elementType = "GsnapOutput"),

-         contains = "List")

+         contains = "GmapAlignerOutputList")

 setClass("SimpleGsnapOutputList",

          contains = c("GsnapOutputList", "SimpleList"))

@@ -181,7 +210,7 @@ GsnapOutputList <- function(...) {

   S4Vectors:::new_SimpleList_from_list("SimpleGsnapOutputList", args)

 }

-setAs("GsnapOutputList", "BamFileList", function(from) {

+setAs("GmapAlignerOutputList", "BamFileList", function(from) {

   BamFileList(lapply(from, as, "BamFile"))

 })

@@ -190,6 +219,6 @@ setAs("GsnapOutputList", "BamFileList", function(from) {

 ### Show

 ###

-setMethod("show", "GsnapOutput", function(object) {

-  cat("A GsnapOutput Object\n", "path: ", path(object), "\n", sep = "")

+setMethod("show", "GmapAlignerOutput", function(object) {

+  cat("A ", class(object), " Object\n", "path: ", path(object), "\n", sep = "")

 })

@@ -9,27 +9,16 @@

 ###

 setClassUnion("integerORNULL", c("integer", "NULL"))

-setClassUnion("GmapSnpsORNULL", c("GmapSnps", "NULL"))

 setClass("GsnapParam",

-         representation(genome = "GmapGenome",

-                        part = "characterORNULL", # used by parallelized_gsnap

-                        batch = "character", # weird "0", "1", ... 

-                        max_mismatches = "integerORNULL",

+         representation(max_mismatches = "integerORNULL",

                         suboptimal_levels = "integer",

-                        snps = "GmapSnpsORNULL",

-                        mode = "character",

-                        nthreads = "integer",

                         novelsplicing = "logical",

                         splicing = "characterORNULL",

-                        npaths = "integer",

-                        quiet_if_excessive = "logical",

-                        nofails = "logical", 

-                        split_output = "logical",

                         terminal_threshold = "integer",

                         gmap_mode = "character",

-                        clip_overlap = "logical",

-                        extra = "list"))

+                        clip_overlap = "logical"),

+         contains="GmapAlignerParam")

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

 ### Accessors

@@ -148,6 +137,27 @@ gsnap_extra <- function(x) {

 ### Constructor

 ###

+newGmapAlignerParam <- function(Class, genome, snps) {

+    if (missing(genome))

+        stop("The 'genome' must be specified (and coercible to GmapGenome)")

+    args <- formals(sys.function(sys.parent(1L)))

+    params <- mget(names(args), parent.frame())

+    params$unique_only <- NULL

+    paramClasses <- getSlots(Class)

+    paramClasses <- paramClasses[setdiff(names(paramClasses),

+                                         c("extra", "snps"))]

+    params <- mapply(as, params[names(paramClasses)], paramClasses,

+                     SIMPLIFY = FALSE)

+    if (!is.null(snps)) {

+        if (!is(snps, "GmapSnps")) {

+            snps <- GmapSnps(snps, genome)

+        }

+        params$snps <- snps

+    }

+    params$extra <- evalq(list(...), parent.frame())

+    do.call(new, c(Class, params))

+}

+

 GsnapParam <- function(genome, unique_only = FALSE, molecule = c("RNA", "DNA"),

                        max_mismatches = NULL,

                        suboptimal_levels = 0L, mode = "standard",

@@ -157,54 +167,43 @@ GsnapParam <- function(genome, unique_only = FALSE, molecule = c("RNA", "DNA"),

                        split_output = !unique_only,

                        novelsplicing = FALSE, splicing = NULL, 

                        nthreads = 1L, part = NULL, batch = "2",

-                       terminal_threshold = if (molecule == "DNA") 1000L else 2L,

-                       gmap_mode = if (molecule == "DNA") "none" else

-                       "pairsearch,terminal,improve",

+                       terminal_threshold =

+                           if (molecule == "DNA") 1000L else 2L,

+                       gmap_mode = if (molecule == "DNA") "none"

+                                   else "pairsearch,terminal,improve",

                        clip_overlap = FALSE, ...)

 {

-  if (missing(genome))

-    stop("The 'genome' must be specified (should be coercible to GmapGenome)")

   molecule <- match.arg(molecule)

-  args <- formals(sys.function())

-  params <- mget(names(args), environment())

-  params$unique_only <- NULL

-  paramClasses <- getSlots("GsnapParam")

-  paramClasses <- paramClasses[setdiff(names(paramClasses), c("extra", "snps"))]

-  params <- mapply(as, params[names(paramClasses)], paramClasses,

-                   SIMPLIFY = FALSE)

-  if (!is.null(snps)) {

-    if (!is(snps, "GmapSnps")) {

-      snps <- GmapSnps(snps, genome)

-    }

-    params$snps <- snps

-  }

-  params$extra <- list(...)

-  do.call(new, c("GsnapParam", params))

+  newGmapAlignerParam("GsnapParam", genome, snps)

 }

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

 ### Coercion

 ###

-setAs("GsnapParam", "list", function(from) {

+GmapAlignerParam_asList <- function(from) {

   to <- lapply(slotNames(from), slot, object = from)

   names(to) <- slotNames(from)

-  to$split_output <- if (to$split_output) "gsnap" else NULL

+  to$split_output <- if (to$split_output) tolower(sub("Param", "", class(from)))

   to$db <- genome(to$genome)

   to$dir <- path(directory(to$genome))

   to$genome <- NULL

   to$use_snps <- name(to$snps)

   to$snpsdir <- path(directory(to$snps))

-  to$novelsplicing <- as.integer(to$novelsplicing)

-  to <- rename(to, splicing = "use_splicing")

   extras <- to$extra

   to <- c(to, extras)

-  to$extra <- NULL

-  

+  to$extra <- NULL  

   to

-})

+}

+

+setAs("GsnapParam", "list", function(from) {

+          to <- GmapAlignerParam_asList(from)

+          to$novelsplicing <- as.integer(to$novelsplicing)

+          to <- rename(to, splicing = "use_splicing")

+          to

+      })

-setMethod("as.list", "GsnapParam", function(x) as(x, "list"))

+as.list.GmapAlignerParam <- function(x) as(x, "list")

 setAs("ANY", "characterORNULL", function(from) {

   if (is.null(from))

@@ -222,7 +221,7 @@ setAs("ANY", "integerORNULL", function(from) {

 ### Show

 ###

-setMethod("show", "GsnapParam", function(object) {

+setMethod("show", "GmapAlignerParam", function(object) {

   slots <- lapply(slotNames(object), slot, object = object)

   names(slots) <- slotNames(object)

   slots$genome <- paste0(slots$genome@name,

@@ -231,6 +230,6 @@ setMethod("show", "GsnapParam", function(object) {

     slots$snps <- paste0(name(slots$snps),

                          " (", path(directory(slots$snps)), ")")

   }

-  cat("A GsnapParams object\n",

+  cat("A ", class(object), " object\n",

       paste0(names(slots), ": ", slots, collapse = "\n"), "\n", sep = "")

 })

@@ -6,6 +6,133 @@

 ### High-level interface

 ###

+setGeneric("gmap", function(input, params, ...) standardGeneric("gmap"))

+

+setMethod("gmap", c("ANY", "GmapParam"),

+          function(input, params, ...) {

+              tmpfile <- tempfile()

+              export(input, tmpfile, format="fasta")

+              input <- tmpfile

+              callGeneric()

+          })

+

+setMethod("gmap", c("FastaFile", "GmapParam"),

+          function(input, params, ...) {

+              input <- path(input)

+              callGeneric()

+          })

+

+setMethod("gmap", c("character", "GmapParam"),

+          function(input, params,

+                   output = file.path(getwd(),

+                       file_path_sans_ext(basename(input), TRUE)), ...)

+              {

+                  if (any(is.na(input)))

+                      stop("'input' must not contain NA's")

+                  if (length(input) > 1L) {

+                      return(GmapOutputList(mapply(gmap, input,

+                                                   MoreArgs =

+                                                       list(params, output,

+                                                            ...))))

+                  }

+                  

+                  output_dir <- dirname(output)

+                  if (!file.exists(output_dir))

+                      dir.create(output_dir, recursive = TRUE)

+

+                  params <- initialize(params, ...)

+                  params_list <- as.list(params)

+                  if (gsnap_split_output(params)) {

+                      params_list$split_output <- output

+                      output_path <- output_dir

+                  } else {

+                      output_path <- paste0(output, ".",

+                                            formatToExt(params$format))

+                      params_list$.redirect <- paste(">", output_path)

+                  }

+

+                  res <- do.call(.gmap,

+                                 c(list(.input = input), params_list))

+                  gmap_output<- GmapOutput(path = output_path,

+                                           version = gmapVersion(),

+                                           param = params)

+

+                  if (params_list$format %in% c("samse", "sampe")) {

+                      gmap_output <- asBam(gmap_output)

+                  }

+                  gmap_output

+              })

+

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

 ### Low-level interface

 ###

+

+.gmap <- function(db = NULL, dir = NULL,

+                  kmer = NULL, basesize = NULL, sampling = NULL,

+                  genomefull = FALSE, gseg = NULL,

+                  selfalign = FALSE, pairalign = FALSE,

+                  part = NULL, input_buffer_size = 1000L,

+                  batch = c("0", "1", "2", "3", "4", "5"),

+                  expand_offsets = FALSE, nosplicing = FALSE,

+                  min_intronlength = 9L, intronlength = 1000000L,

+                  localsplicedist = 2000000L, totallength = 2400000L,

+                  chimera_margin = 40L, no_chimeras = FALSE,

+                  nthreads = NULL, chrsubsetfile = NULL,

+                  direction = c("auto", "sense_force", "antisense_force",

+                      "sense_filter", "antisense_filter"),

+                  trimendexons = 12L, canonical_mode = c("1", "0", "2"),

+                  cross_species = FALSE, allow_close_indels = c("1", "0", "2"),

+                  microexon_spliceprob = 0.90, cmetdir = NULL, atoidir = NULL,

+                  mode = c("standard", "cmet-stranded", "cmet-nonstranded",

+                      "atoi-stranded", "atoi-nonstranded"),

+                  prunelevel = c("0", "1", "2", "3"),

+                  format = NULL, npaths = 5L, quiet_if_excessive = FALSE,

+                  suboptimal_score = NULL, ordered = FALSE, md5 = FALSE,

+                  chimera_overlap = FALSE, failsonly = FALSE, nofails = FALSE,

+                  fails_as_input = FALSE, snpsdir = NULL, use_snps = NULL,

+                  split_output = NULL, append_output = FALSE,

+                  output_buffer_size = 1000L, fulllength = FALSE,

+                  cdsstart = NULL, truncate = FALSE, tolerant = FALSE,

+                  no_sam_headers = FALSE, sam_use_0M = FALSE,

+                  force_xs_dir = FALSE, md_lowercase_snp = FALSE,

+                  read_group_id = NULL, read_group_name = NULL,

+                  read_group_library = NULL, read_group_platform = NULL,

+                  quality_protocol = c("sanger", "illumina"),

+                  quality_print_shift = 0L, mapdir = NULL, map = NULL,

+                  mapexons = FALSE, mapboth = FALSE, version = FALSE,

+                  .input = NULL, .redirect = NULL)

+{

+    formals <- formals(sys.function())

+

+    expand_offsets <- as.integer(expand_offsets)

+    batch <- match.arg(batch)

+    direction <- match.arg(direction)

+    canonical_mode <- match.arg(canonical_mode)

+    allow_close_indels <- match.arg(allow_close_indels)

+    mode <- match.arg(mode)

+    prunelevel <- match.arg(prunelevel)

+    quality_protocol <- match.arg(quality_protocol)

+    

+    if (version) {

+        .redirect <- ">/dev/null"

+    }

+

+### TODO: if input_a is NULL, or split_output and .redirect are NULL:

+###       return a pipe()

+    .system_gsnap(commandLine("gmap"))

+}

+

+..gmap <- function(args, path = NULL) {

+    .system_gsnap(.commandLine("gmap", args, path))

+}

+

+### - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

+### Utilities

+###

+

+gmapVersion <- function() {

+    output <- .gmap(version = TRUE)

+    version_text <- sub("GMAP version (.*?) .*", "\\1", output[1])

+    parseGsnapVersion(version_text)

+}

+

@@ -125,6 +125,10 @@ setMethod("gsnap", c("character", "characterORNULL", "GsnapParam"),

   mode <- match.arg(mode)

   quality_protocol <- match.arg(quality_protocol)

   filter_chastity <- match.arg(filter_chastity)

+

+  if (version) {

+      .redirect <- ">/dev/null"

+  }

 ### TODO: if input_a is NULL, or split_output and .redirect are NULL:

 ###       return a pipe()