@@ -1,7 +1,7 @@

 Package: RNAmodR

 Type: Package

 Title: Detection of post-transcriptional modifications

-Version: 0.99.17

+Version: 0.99.18

 Date: 2019-05-31

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

                     "Ernst", 

@@ -627,12 +627,19 @@ setReplaceMethod(f = "settings",

   proto <- new(className)  # create prototype object for mod normalization only

   data <- .norm_Modifier_input_SequenceData_elements(data, proto)

   bamfiles <- bamfiles(data)

-  condition <- factor(names(bamfiles))

+  # setup conditions and replicates

+  conditions <- .norm_conditions(data)

+  replicates <- .norm_replicates(data)

+  ia <- as.integer(interaction(conditions,replicates))

+  m <- match(unique(ia),ia)

+  condition <- conditions[m]

+  replicate <- replicates[m]

+  # create Modifier object

   new(className,

       mod = .norm_mod(proto@mod, className),

       bamfiles = bamfiles,

       condition = condition,

-      replicate = .get_replicate_number(condition),

+      replicate = replicate,

       data = data)

 }

@@ -171,16 +171,18 @@ NULL

   unlisted_coord <- unlist(coord,use.names = FALSE)

   if(!is.null(unlisted_coord$Activity) || !is.null(unlisted_coord$mod)){

     f <- match(start(coord),relist(data$positions,partitioning_data))

+    ff <- !is.na(f)

+    f <- f[ff]

     f <- f + start(IRanges::PartitioningByEnd(f)) - 1L

     f <- unlist(f)

     if(!is.null(unlisted_coord$Activity)){

       data$Activity <- ""

       data$Activity[f] <- vapply(unlisted_coord$Activity, paste, character(1),

-                                 collapse = "/")

+                                 collapse = "/")[unlist(ff)]

     }

     if(!is.null(unlisted_coord$mod)){

       data$mod <- ""

-      data$mod[f] <- unlisted_coord$mod

+      data$mod[f] <- unlisted_coord$mod[unlist(ff)]

     }

   }

   # convert ids to names for labeling if present

@@ -345,16 +345,11 @@ setMethod(

       ia <- interaction(conditions(x), replicates(x))

       if(is.character(j)){

         j <- normalizeSingleBracketSubscript(j, xstub)

-        j <- as.integer(ia)[j]

+        j <- unique(as.integer(ia)[j])

+      } else {

+        conditionsFmultiplier <- length(ia) / length(unique(ia))

+        j <- normalizeSingleBracketSubscript(j, xstub[seq_len(length(ia)/conditionsFmultiplier)])

       }

-      colnames <- IRanges::CharacterList(strsplit(colnames(x),"\\."))

-      colnames_conditions <- colnames %in% c("treated","control")

-      colnames_replicates <- !is.na(suppressWarnings(IntegerList(colnames)))

-      colnames_f <- !(colnames_conditions | colnames_replicates)

-      conditionsFmultiplier <- length(unique(vapply(colnames[colnames_f],

-                                                    paste,character(1),

-                                                    collapse=".")))

-      j <- normalizeSingleBracketSubscript(j, xstub[seq_len(length(xstub)/conditionsFmultiplier)])

       j2 <- which(!is.na(match(as.integer(ia), j)))

       x <- initialize(x,

                       as(x,"DataFrame")[, j2, drop = FALSE],

@@ -286,16 +286,30 @@ setMethod(f = "bamfiles",

 setMethod(f = "conditions", 

           signature = signature(object = "SequenceDataSet"),

           definition = function(object){

-            ans <- IRanges::FactorList(lapply(object,conditions))

-            ans

+            ans <- IRanges::FactorList(

+              lapply(object[1L],

+                     function(o){

+                       ia <- as.integer(interaction(conditions(o),

+                                                    replicates(o)))

+                       m <- match(unique(ia),ia)

+                       conditions(o)[m]

+                     }))

+            ans[[1L]]

           })

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "replicates", 

           signature = signature(x = "SequenceDataSet"),

           definition = function(x){

-            ans <- IRanges::FactorList(lapply(x,replicates))

-            ans

+            ans <- IRanges::FactorList(

+              lapply(x[1L],

+                     function(o){

+                       ia <- as.integer(interaction(conditions(o),

+                                                    replicates(o)))

+                       m <- match(unique(ia),ia)

+                       replicates(o)[m]

+                     }))

+            ans[[1L]]

           })

 # aggregate --------------------------------------------------------------------

@@ -283,3 +283,21 @@ SAMPLE_TYPES <- c("treated","control")

   }

   data

 }

+

+# conditions and replicates ----------------------------------------------------

+

+.norm_conditions <- function(x){

+  conditions <- conditions(x)

+  if(is(x,"SequenceDataList")){

+    conditions <- conditions[[1L]]

+  }

+  conditions

+}

+

+.norm_replicates <- function(x){

+  replicates <- replicates(x)

+  if(is(x,"SequenceDataList")){

+    replicates <- replicates[[1L]]

+  }

+  replicates

+}

@@ -14,11 +14,11 @@ test_that("SequenceDataSet:",{

   expect_equal(sequences(sds),sequences(sds[[1]]))

   expect_equal(bamfiles(sds),bamfiles(sds[[1]]))

   actual <- conditions(sds)

-  expect_s4_class(actual,"FactorList")

-  expect_equal(actual[[1]],factor(c("treated","treated","treated")))

+  expect_is(actual,"factor")

+  expect_equal(actual,factor(c("treated","treated","treated")))

   actual <- replicates(sds)

-  expect_s4_class(actual,"FactorList")

-  expect_equal(actual[[1]],factor(c(1,2,3)))

+  expect_is(actual,"factor")

+  expect_equal(actual,factor(c(1,2,3)))

   ##############################################################################

   # expect_equal(aggregate(sds),

   #              SimpleList(End5SequenceData = aggregate(sds[[1]]),

@@ -57,16 +57,14 @@ test_that("SequenceDataList:",{

   skip_on_bioc()

   actual <- conditions(sdl)

   expect_s4_class(actual,"SimpleList")

-  expect_s4_class(actual[[1]],"FactorList")

-  expect_true(is.factor(actual[[1]][[1]]))

-  expect_equal(actual[[1]][[1]],actual[[2]])

-  expect_equal(actual[[1]][[1]],factor(c("treated","treated","treated")))

+  expect_is(actual[[1]],"factor")

+  expect_equal(actual[[1]],actual[[2]])

+  expect_equal(actual[[1]],factor(c("treated","treated","treated")))

   actual <- replicates(sdl)

   expect_s4_class(actual,"SimpleList")

-  expect_s4_class(actual[[1]],"FactorList")

-  expect_true(is.factor(actual[[1]][[1]]))

-  expect_equal(actual[[1]][[1]],actual[[2]])

-  expect_equal(actual[[1]][[1]],factor(c(1,2,3)))

+  expect_is(actual[[1]],"factor")

+  expect_equal(actual[[1]],actual[[2]])

+  expect_equal(actual[[1]],factor(c(1,2,3)))

   expect_equal(ranges(sdl),ranges(sdl[[1]]))

   expect_equal(sequences(sdl),sequences(sdl[[1]]))

   ##############################################################################