@@ -1,8 +1,8 @@

 Package: RNAmodR

 Type: Package

 Title: Detection of post-transcriptional modifications in high throughput sequencing data

-Version: 1.5.2

-Date: 2020-12-12

+Version: 1.5.3

+Date: 2021-01-12

 Authors@R: c(person("Felix G.M.", 

                     "Ernst", 

                     email = "felix.gm.ernst@outlook.com", 

@@ -149,8 +149,12 @@ importClassesFrom(Rsamtools,BamFileList)

 importClassesFrom(Rsamtools,PileupFiles)

 importFrom(BSgenome,seqnames)

 importFrom(BiocParallel,SerialParam)

+importFrom(BiocParallel,bpisup)

 importFrom(BiocParallel,bplapply)

 importFrom(BiocParallel,bpmapply)

+importFrom(BiocParallel,bpparam)

+importFrom(BiocParallel,bpstart)

+importFrom(BiocParallel,bpstop)

 importFrom(BiocParallel,register)

 importFrom(Biostrings,"seqtype<-")

 importFrom(Biostrings,DNAString)

@@ -12,3 +12,7 @@ Changes in version 1.3.5 (2020-08-30)

 Changes in version 1.5.2 (2020-12-12)

 + bugfix for names plotted by plotCompareByCoord

+

+Changes in version 1.5.3 (2021-01-12)

++ bugfix for zero-length annotation

++ bugfix for settings function

@@ -176,13 +176,15 @@ ModInosine <- function(x, annotation, sequences, seqinfo, ...){

 #' @rdname ModInosine-functions

 #' @export

 setReplaceMethod(f = "settings", 

-                 signature = signature(x = "ModInosine"),

-                 definition = function(x, value){

-                   x <- callNextMethod()

-                   value <- .norm_ModInosine_settings(value)

-                   x@settings[names(value)] <- unname(value)

-                   x

-                 })

+    signature = signature(x = "ModInosine"),

+    definition = function(x, value){

+        x <- callNextMethod()

+        names <- names(value)

+        value <- .norm_ModInosine_settings(value)

+        x <- .add_settings_value(x, value, names)

+        x

+    }

+)

 # functions --------------------------------------------------------------------

@@ -643,37 +643,51 @@ NULL

 #' @rdname settings

 #' @export

-setMethod(f = "settings",

-          signature = signature(x = "Modifier"),

-          definition = function(x, name){

-            if(missing(name) || is.null(name)){

-              return(x@settings)

-            }

-            if(!.is_a_string(name)){

-              stop("'name' must be a single character value.",

-                   call. = FALSE)

-            }

-            x@settings[[name]]

-          }

+setMethod(f = "settings", signature = signature(x = "Modifier"),

+    definition = function(x, name){

+        if(missing(name) || is.null(name)){

+            return(x@settings)

+        }

+        if(!.is_a_string(name)){

+            stop("'name' must be a single character value.",

+                 call. = FALSE)

+        }

+        x@settings[[name]]

+    }

 )

+.add_settings_value <- function(x, value, names){

+    if(is.null(names)){

+        names <- names(value)

+    } else {

+        names <- names[names %in% names(value)]

+    }

+    if(length(names) != 0L){

+        value <- value[names]

+        x@settings[names(value)] <- unname(value)

+    }

+    x

+}

+

 #' @rdname settings

 #' @export

 setReplaceMethod(f = "settings",

-                 signature = signature(x = "Modifier"),

-                 definition = function(x, value){

-                   if(is.null(names(value)) && length(value) > 0L){

-                     stop("'value' has to be a named.", call. = FALSE)

-                   }

-                   if(!is.list(value)){

-                     value <- as.list(value)

-                   }

-                   value <- .norm_Modifier_settings(value)

-                   x@settings[names(value)] <- unname(value)

-                   x@aggregateValidForCurrentArguments <- FALSE

-                   x@modificationsValidForCurrentArguments <- FALSE

-                   x

-                 })

+    signature = signature(x = "Modifier"),

+    definition = function(x, value){

+        if(is.null(names(value)) && length(value) > 0L){

+            stop("'value' has to be a named.", call. = FALSE)

+        }

+        if(!is.list(value)){

+            value <- as.list(value)

+        }

+        names <- names(value)

+        value <- .norm_Modifier_settings(value)

+        x <- .add_settings_value(x, value, names)

+        x@aggregateValidForCurrentArguments <- FALSE

+        x@modificationsValidForCurrentArguments <- FALSE

+        x

+    }

+)

 # constructors -----------------------------------------------------------------

@@ -710,9 +724,15 @@ setReplaceMethod(f = "settings",

       data = data)

 }

+#' @importFrom BiocParallel bpparam bpisup bpstart bpstop bpmapply bplapply

 .load_SequenceData <- function(classes, bamfiles, annotation, sequences,

                                seqinfo, args){

   if(is.list(classes)){

+    BPPARAM <- bpparam()

+    if (!(bpisup(BPPARAM) || is(BPPARAM, "MulticoreParam"))) {

+      bpstart(BPPARAM)

+      on.exit(bpstop(BPPARAM), add = TRUE)

+    }

     if(is.list(bamfiles)){

       if(length(classes) != length(bamfiles)){

         stop("'x' has invalid length. '",paste(classes, collapse = "' and '"),

@@ -730,13 +750,15 @@ setReplaceMethod(f = "settings",

              call. = FALSE)

       }

       bamfiles <- bamfiles[match(class,names(bamfiles))]

-      data <- BiocParallel::bpmapply(.load_SequenceData, classes, bamfiles,

-                                     MoreArgs = list(annotation, sequences,

-                                                     seqinfo, args),

-                                     SIMPLIFY = FALSE)

+      data <- bpmapply(.load_SequenceData, classes, bamfiles,

+                       MoreArgs = list(annotation, sequences,

+                                       seqinfo, args),

+                       SIMPLIFY = FALSE,

+                       BPPARAM = BPPARAM)

     } else {

-      data <- BiocParallel::bplapply(classes, .load_SequenceData, bamfiles,

-                                     annotation, sequences, seqinfo, args)

+      data <- bplapply(classes, .load_SequenceData, bamfiles,

+                       annotation, sequences, seqinfo, args,

+                       BPPARAM = BPPARAM)

     }

     data <- as(data,"SequenceDataList")

   } else if(is.character(classes)){

@@ -767,6 +789,7 @@ setReplaceMethod(f = "settings",

   }

   bamfiles <- .norm_bamfiles(x, className) # check bam files

   # settings

+  settings(proto) <- list()

   settings(proto) <- list(...)

   #

   annotation <- .norm_annotation(annotation, className)

@@ -786,6 +809,7 @@ setReplaceMethod(f = "settings",

   # create Modifier object

   ans <- .Modifier(className, x)

   # settings

+  settings(ans) <- list()

   settings(ans) <- list(...)

   # aggregate data

   message("Aggregating data and calculating scores ... ", appendLF = FALSE)

@@ -503,35 +503,48 @@ setMethod(f = "settings",

 #' @rdname settings

 #' @export

 setReplaceMethod(f = "settings", 

-                 signature = signature(x = "ModifierSet"),

-                 definition = function(x, value){

-                   for(i in seq_along(x)){

-                     settings(x[[i]]) <- value

-                   }

-                   x

-                 })

+    signature = signature(x = "ModifierSet"),

+    definition = function(x, value){

+        for(i in seq_along(x)){

+            settings(x[[i]]) <- value

+        }

+        x

+    }

+)

 # aggregate/modify -------------------------------------------------------------

 #' @rdname aggregate

+#' @importFrom BiocParallel bpparam bpisup bpstart bpstop bpmapply bplapply

 #' @export

 setMethod(f = "aggregate", 

-          signature = signature(x = "ModifierSet"),

-          definition = 

-            function(x, force = FALSE){

-              ans <- BiocParallel::bplapply(x,aggregate,force)

-              ans <- RNAmodR::ModifierSet(class(x),ans)

-              ans

-            }

+    signature = signature(x = "ModifierSet"),

+    definition = 

+    function(x, force = FALSE){

+        BPPARAM <- bpparam()

+        if (!(bpisup(BPPARAM) || is(BPPARAM, "MulticoreParam"))) {

+            bpstart(BPPARAM)

+            on.exit(bpstop(BPPARAM), add = TRUE)

+        }

+        ans <- BiocParallel::bplapply(x,aggregate,force,BPPARAM=BPPARAM)

+        ans <- RNAmodR::ModifierSet(class(x),ans)

+        ans

+    }

 )

 #' @rdname modify

+#' @importFrom BiocParallel bpparam bpisup bpstart bpstop bpmapply bplapply

 #' @export

 setMethod(f = "modify", 

-          signature = signature(x = "ModifierSet"),

-          definition = 

-            function(x, force = FALSE){

-              ans <- BiocParallel::bplapply(x,modify,force)

-              ans <- RNAmodR::ModifierSet(class(x),ans)

-              ans

-            }

+    signature = signature(x = "ModifierSet"),

+    definition = 

+    function(x, force = FALSE){

+        BPPARAM <- bpparam()

+        if (!(bpisup(BPPARAM) || is(BPPARAM, "MulticoreParam"))) {

+            bpstart(BPPARAM)

+            on.exit(bpstop(BPPARAM), add = TRUE)

+        }

+        ans <- BiocParallel::bplapply(x,modify,force,BPPARAM=BPPARAM)

+        ans <- RNAmodR::ModifierSet(class(x),ans)

+        ans

+    }

 )

@@ -51,6 +51,10 @@ NULL

 }

 .norm_annotation_GRangesList <- function(annotation){

+  annotation <- annotation[lengths(annotation)!= 0]

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

+    stop("'annotation' has a length == 0L.")

+  }

   if(is.null(names(annotation))){

     stop("Elements of 'annotation' GRangesList must be named.")

   }

@@ -48,6 +48,16 @@ test_that("Modifier/ModifierSet:",{

   actual <- settings(msi[[1]])

   expect_type(actual,"list")

   expect_named(actual,c("minCoverage","minReplicate","find.mod","minScore"))

+  expect_equal(actual[["find.mod"]],TRUE)

+  settings(msi[[1]]) <- list("find.mod" = FALSE)

+  settings(msi[[1]]) <- list("minReplicate" = 3L)

+  settings(msi[[1]]) <- list("minCoverage" = 20L)

+  actual <- settings(msi[[1]])

+  expect_equal(actual[["find.mod"]],FALSE)

+  expect_equal(actual[["minReplicate"]],3L)

+  expect_equal(actual[["minCoverage"]],20L)

+  rm(msi)

+  data(msi,package = "RNAmodR")

   # Modifier accessors

   expect_type(names(msi[[1]]),"character")

   expect_type(modifierType(msi[[1]]),"character")