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

 Package: RNAmodR

 Type: Package

 Title: Detection of post-transcriptional modifications

-Version: 0.99.16

-Date: 2019-05-28

+Version: 0.99.17

+Date: 2019-05-31

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

                     "Ernst", 

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

@@ -23,6 +23,7 @@ export(PileupSequenceDataFrame)

 export(ProtectedEndSequenceData)

 export(ProtectedEndSequenceDataFrame)

 export(RNASequenceTrack)

+export(SequenceData)

 export(SequenceDataList)

 export(SequenceDataSet)

 export(aggregate)

@@ -84,9 +85,11 @@ exportMethods("[")

 exportMethods("settings<-")

 exportMethods(Modifier)

 exportMethods(ModifierSet)

+exportMethods(SequenceData)

 exportMethods(aggregate)

 exportMethods(aggregateData)

 exportMethods(bamfiles)

+exportMethods(cbind)

 exportMethods(compareByCoord)

 exportMethods(conditions)

 exportMethods(dataType)

@@ -108,6 +111,7 @@ exportMethods(plotData)

 exportMethods(plotDataByCoord)

 exportMethods(plotROC)

 exportMethods(ranges)

+exportMethods(rbind)

 exportMethods(replicates)

 exportMethods(seqinfo)

 exportMethods(sequenceData)

@@ -383,7 +383,7 @@ setMethod(f = "bamfiles",

 setMethod(f = "conditions",

           signature = signature(object = "Modifier"),

           definition = function(object){

-            conditions(sequenceData(object))

+            object@condition

           })

 #' @rdname Modifier-functions

 #' @export

@@ -461,7 +461,7 @@ setMethod(f = "ranges",

 setMethod(f = "replicates",

           signature = signature(x = "Modifier"),

           definition = function(x){

-            replicates(sequenceData(x))

+            x@replicate

           })

 #' @rdname Modifier-functions

 #' @export

@@ -628,12 +628,12 @@ setReplaceMethod(f = "settings",

   data <- .norm_Modifier_input_SequenceData_elements(data, proto)

   bamfiles <- bamfiles(data)

   condition <- factor(names(bamfiles))

-  new2(className,

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

-       bamfiles = bamfiles,

-       condition = condition,

-       replicate = .get_replicate_number(bamfiles, condition),

-       data = data)

+  new(className,

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

+      bamfiles = bamfiles,

+      condition = condition,

+      replicate = .get_replicate_number(condition),

+      data = data)

 }

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

@@ -9,6 +9,8 @@ NULL

 #' 

 #' @title The SequenceData class

 #' 

+#' @md

+#' 

 #' @description 

 #' The \code{SequenceData} class is implemented to contain data on each position

 #' along transcripts and holds the corresponding annotation data and

@@ -37,8 +39,20 @@ NULL

 #' The \code{SequenceData} class is derived from the

 #' \code{\link[IRanges:DataFrameList-class]{CompressedSplitDataFrameList}} class

 #' with additional slots for annotation and sequence data. Some functionality is

-#' not inherited and not available, e.g. \code{cbind}, \code{rbind} amd

-#' \code{relist}.

+#' not inherited and might not available to full extend, e.g.\code{relist}.

+#' 

+#' **SequenceDataFrame**

+#' 

+#' #' The \code{SequenceDataFrame} class contains data for positions along a single

+#' transcript. It is used to describe elements from a \code{SequenceData}

+#' object.

+#' 

+#' The \code{SequenceDataFrame} class is derived from the

+#' \code{\link[S4Vectors:DataFrame-class]{DataFrame}} class.

+#' 

+#' Subsetting of a \code{SequenceDataFrame} returns a \code{SequenceDataFrame} or 

+#' \code{DataFrame}, if it is subset by a column or row, respectively. The 

+#' \code{drop} argument is ignored for column subsetting.

 #' 

 #' @param dataType The prefix for construction the class name of the 

 #' \code{SequenceData} subclass to be constructed.

@@ -68,6 +82,8 @@ NULL

 #' \item{\code{max_depth}} {maximum depth for pileup loading (default: 

 #' \code{max_depth = 10000L}).}

 #' }

+#' @param deparse.level See \code{\link[base:cbind]{base::cbind}} for a 

+#' description of this argument.

 #' 

 #' @slot ranges a \code{\link[GenomicRanges:GRangesList-class]{GRangesList}} 

 #' object each element describing a transcript including its element. The 

@@ -96,8 +112,6 @@ NULL

 setClass("SequenceData",

          contains = c("VIRTUAL", "CompressedSplitDataFrameList"),

          slots = c(sequencesType = "character",

-                   bamfiles = "BamFileList",

-                   seqinfo = "Seqinfo",

                    minQuality = "integer",

                    unlistData = "SequenceDataFrame",

                    unlistType = "character",

@@ -192,12 +206,33 @@ S4Vectors::setValidity2(Class = "SequenceData", .valid.SequenceData)

 # coercion ---------------------------------------------------------------------

-.as_SplitDataFrameList <- function(from){

-  relist(as(unlist(from, use.names = FALSE),"DataFrame"),

-         IRanges::PartitioningByWidth(from))

+coerceToSequenceData <- function(className) {

+  function(from) {

+    if(is.list(from)) {

+      classes <- unlist(lapply(from,class))

+      from <- from[classes == paste0(className,"Frame")]

+      if(length(from) == 0) {

+        FUN <- match.fun(className)

+        from <- list(FUN())

+      }

+    } else {

+      if(is(from,className)){

+        return(from)

+      } else if(is(from,paste0(className,"Frame"))) {

+        from <- list(from)

+      } else {

+        stop("Cannot coerce ",class(from)," to ",className,".")

+      }

+    }

+    IRanges:::coerceToCompressedList(from)

+  }

 }

-setAs("SequenceData", "SplitDataFrameList", .as_SplitDataFrameList)

+setSequenceDataCoercions <- function(type) {

+  className <- sequenceDataClass(type)

+  setAs("ANY", className, coerceToSequenceData(className))

+  setAs("list", className, coerceToSequenceData(className))

+}

 # internals --------------------------------------------------------------------

@@ -223,8 +258,7 @@ setMethod("extractROWS", "SequenceData",

     ans_partitioning <- new("PartitioningByEnd", end = ans_breakpoints,

                             NAMES = extractROWS(names(x), i))

     ans_elementMetadata <- extractROWS(x@elementMetadata, i)

-    initialize(x, bamfiles = x@bamfiles, seqinfo = x@seqinfo, 

-               minQuality = x@minQuality, unlistData = ans_unlistData,

+    initialize(x, minQuality = x@minQuality, unlistData = ans_unlistData,

                partitioning = ans_partitioning, 

                elementMetadata = ans_elementMetadata)

   }

@@ -237,35 +271,115 @@ setMethod("rownames", "SequenceData",

           }

 )

-# methods inherited from List and CompressedList, contain a coercion step

-# x <- as(x, "List", strict = FALSE)

-# 

-# This does not keep the SequenceData object intact resulting in coercion

-# to a CompressedSplitDataFrameList.

-setMethod("[[", "SequenceData",

-          function(x, i, j, ...) 

-          {

-            METHOD <- selectMethod("[[", "List")

-            METHOD(x, i, j, ...)

-          }

-)

+# Concatenation ----------------------------------------------------------------

+.check_ranges <- function(args){

+  ranges <- lapply(args,ranges)

+  ranges <- vapply(ranges[seq.int(2L,length(ranges))],

+                   function(r){

+                     all(all(r == ranges[[1L]]))

+                   },

+                   logical(1))

+  if(!all(ranges)){

+    stop("Inputs must have the same ranges.")

+  }

+}

-# Concatenation ----------------------------------------------------------------

+.check_sequences <- function(args){

+  sequences <- lapply(args,sequences)

+  sequences <- vapply(sequences[seq.int(2L,length(sequences))],

+                      function(s){

+                        all(s == sequences[[1L]])

+                      },

+                      logical(1))

+  if(!all(sequences)){

+    stop("Inputs must have the same sequences.")

+  }

+}

-setMethod("cbind", "SequenceData",

-          function(...){

-            arg1 <- list(...)[[1L]]

-            stop("'rbind' is not supported for ",class(arg1),".")

+.check_bamfiles <- function(args){

+  bamfiles <- lapply(args,bamfiles)

+  bamfiles <- vapply(bamfiles[seq.int(2L,length(bamfiles))],

+                     function(b){

+                       all(path(b) == path(bamfiles[[1L]]))

+                     },

+                     logical(1))

+  if(!all(bamfiles)){

+    stop("Inputs must be derived from the same bamfiles.")

   }

+}

+

+#' @rdname SequenceData-class

+#' @export

+setMethod("cbind", "SequenceData",

+          function(..., deparse.level = 1) 

+          {

+            args <- list(...)

+            if(length(args) == 1L){

+              return(args[[1L]])

+            }

+            # input checks

+            classes <- lapply(args,class)

+            if(length(unique(classes)) != 1L){

+              stop("Inputs must be of the same SequenceDataFrame type.")

+            }

+            lengths <- vapply(args,function(a){sum(lengths(a))},integer(1))

+            if(length(unique(lengths)) != 1L){

+              stop("Inputs must have the same lengths.")

+            }

+            .check_ranges(args)

+            .check_sequences(args)

+            callNextMethod()

+          }

 )

+

+#' @rdname SequenceData-class

+#' @export

 setMethod("rbind", "SequenceData",

-          function(...){

-            arg1 <- list(...)[[1L]]

-            stop("'rbind' is not supported for ",class(arg1),".")

+          function(..., deparse.level = 1) 

+          {

+            args <- list(...)

+            if(length(args) == 1L){

+              return(args[[1L]])

+            }

+            # input checks

+            classes <- lapply(args,class)

+            if(length(unique(classes)) != 1L){

+              stop("Inputs must be of the same SequenceDataFrame type.")

+            }

+            lengths <- vapply(args,function(a){ncol(unlist(a))},integer(1))

+            if(length(unique(lengths)) != 1L){

+              stop("Inputs must have the same width.")

+            }

+            .check_bamfiles(args)

+            callNextMethod()

           }

 )

+setMethod("bindROWS", "SequenceData",

+          function (x, objects = list(), use.names = TRUE, ignore.mcols = FALSE, 

+                    check = TRUE) 

+          {

+            objects <- S4Vectors:::prepare_objects_to_bind(x, objects)

+            all_objects <- c(list(x), objects)

+            names <- unlist(lapply(all_objects,names))

+            if(any(duplicated(names))){

+              stop("Input must have unique names.")

+            }

+            .check_bamfiles(all_objects)

+            callNextMethod(x, objects, use.names = use.names, 

+                           ignore.mcols = ignore.mcols, check = FALSE)

+          }

+)

+

+setMethod("unlist", "SequenceData",

+          function(x, recursive = TRUE, use.names = FALSE) 

+          {

+            callNextMethod(x, recursive = recursive, use.names = FALSE) 

+          }

+)

+

+

 # constructor ------------------------------------------------------------------

 .quality_settings <- data.frame(

@@ -279,9 +393,9 @@ setMethod("rbind", "SequenceData",

   .norm_settings(input, .quality_settings, minQuality)[["minQuality"]]

 }

-.get_replicate_number <- function(bamfiles, conditions){

-  control_rep <- seq_along(bamfiles[conditions == "control"])

-  treated_rep <- seq_along(bamfiles[conditions == "treated"])

+.get_replicate_number <- function(conditions){

+  control_rep <- seq_along(conditions[conditions == "control"])

+  treated_rep <- seq_along(conditions[conditions == "treated"])

   rep <- c(control_rep,treated_rep)

   rep <- rep[c(which(conditions == "control"),

                which(conditions == "treated"))]

@@ -365,7 +479,7 @@ setMethod("rbind", "SequenceData",

   proto <- new(className)

   minQuality <- .norm_min_quality(args, proto@minQuality)

   condition <- factor(names(bamfiles))

-  replicate <- .get_replicate_number(bamfiles, condition)

+  replicate <- .get_replicate_number(condition)

   if(!assertive::is_a_non_empty_string(proto@dataDescription)){

     stop("'dataDescription' must be a single non empty character value.")

   }

@@ -419,16 +533,18 @@ setMethod("rbind", "SequenceData",

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

   # Create SequenceData object

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

+  unlist_data <- 

+    .SequenceDataFrame(class = gsub("SequenceData","",className),

+                       df = unlist(data, use.names = FALSE),

+                       ranges = unlist(ranges, use.names = FALSE),

+                       sequence = unlist(sequences, use.names = FALSE),

+                       replicate = replicate,

+                       condition = condition,

+                       bamfiles = bamfiles,

+                       seqinfo = seqinfo)

   ans <- new(className, 

-             bamfiles = bamfiles,

-             seqinfo = seqinfo,

              minQuality = minQuality,

-             unlistData = .SequenceDataFrame(gsub("SequenceData","",className),

-                                             unlist(data, use.names = FALSE),

-                                             unlist(ranges, use.names = FALSE),

-                                             unlist(sequences, use.names = FALSE),

-                                             replicate,

-                                             condition),

+             unlistData = unlist_data,

              partitioning = IRanges::PartitioningByEnd(data),

              ...)

   message("OK")

@@ -558,6 +674,8 @@ setMethod("rbind", "SequenceData",

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

+#' @rdname SequenceData-class

+#' @export

 setGeneric( 

   name = "SequenceData",

   signature = c("annotation","sequences"),

@@ -565,72 +683,96 @@ setGeneric(

     standardGeneric("SequenceData")

 ) 

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "character", sequences = "character"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "character", sequences = "BSgenome"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "TxDb", sequences = "character"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "TxDb", sequences = "BSgenome"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "GRangesList", sequences = "character"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "GRangesList", sequences = "BSgenome"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "GFF3File", sequences = "BSgenome"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "GFF3File", sequences = "character"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "character", sequences = "FaFile"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "GFF3File", sequences = "FaFile"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "TxDb", sequences = "FaFile"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

             .new_SequenceData(dataType, bamfiles, annotation, sequences,

                               seqinfo, ...)

           })

+#' @rdname SequenceData-class

+#' @export

 setMethod("SequenceData",

           signature = c(annotation = "GRangesList", sequences = "FaFile"),

           function(dataType, bamfiles, annotation, sequences, seqinfo, ...){

@@ -659,7 +801,7 @@ setMethod("getData",

 #' @export

 setMethod(f = "bamfiles", 

           signature = signature(x = "SequenceData"),

-          definition = function(x){x@bamfiles})

+          definition = function(x){bamfiles(unlist(x))})

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "conditions", 

@@ -674,12 +816,12 @@ setMethod(

     function(x){

       partitioning <- IRanges::PartitioningByEnd(x)

       unlisted_ranges <- ranges(unlist(x))

-      ends <- cumsum(width(unlisted_ranges)) == cumsum(width(partitioning))

-      partitioning_relist <- IRanges::PartitioningByEnd(which(ends))

-      names(partitioning_relist) <- names(x)

+      ends <- match(cumsum(width(partitioning)),cumsum(width(unlisted_ranges)))

+      partitioning_relist <- IRanges::PartitioningByEnd(ends)

       if(length(x) != length(partitioning_relist)){

         stop("ranges could not be relisted.")

       }

+      names(partitioning_relist) <- names(x)

       relist(unlisted_ranges, partitioning_relist)

     })

 #' @rdname SequenceData-functions

@@ -691,7 +833,7 @@ setMethod(f = "replicates",

 #' @export

 setMethod(f = "seqinfo", 

           signature = signature(x = "SequenceData"),

-          definition = function(x){x@seqinfo})

+          definition = function(x){seqinfo(unlist(x))})

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "sequences", 

@@ -25,6 +25,9 @@ NULL

 #' of \code{ranges(x)}

 #' @param condition For \code{\link{aggregate}}: condition for which the data 

 #' should be aggregated.

+#' @param df,ranges,sequence,replicate inputs for creating a 

+#' \code{SequenceDataFrame}. See 

+#' \code{\link[=SequenceDataFrame-class]{SequenceDataFrame}}.

 #' 

 #' @return a \code{CoverageSequenceData} object

 #' 

@@ -47,8 +50,9 @@ setClass(Class = "CoverageSequenceDataFrame",

 #' @rdname CoverageSequenceData-class

 #' @export

 CoverageSequenceDataFrame <- function(df, ranges, sequence, replicate,

-                                      condition){

-  .SequenceDataFrame("Coverage",df, ranges, sequence, replicate, condition)

+                                      condition, bamfiles, seqinfo){

+  .SequenceDataFrame("Coverage",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname CoverageSequenceData-class

 #' @export

@@ -66,6 +70,8 @@ CoverageSequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

                     sequences = sequences, seqinfo = seqinfo, ...)

 }

+setSequenceDataCoercions("Coverage")

+

 # CoverageSequenceData ---------------------------------------------------------

 .process_coverage_data <- function(coverage, grl){

@@ -28,6 +28,9 @@ NULL

 #' transcript name. Must be a name of \code{ranges(x).}

 #' @param condition For \code{\link{aggregate}}: condition for which the data

 #' should be aggregated.

+#' @param df,ranges,sequence,replicate inputs for creating a 

+#' \code{SequenceDataFrame}. See 

+#' \code{\link[=SequenceDataFrame-class]{SequenceDataFrame}}.

 #'

 #' @return a \code{End5SequenceData}, a \code{End3SequenceData} or a

 #' \code{EndSequenceData} object

@@ -50,8 +53,9 @@ setClass(Class = "End5SequenceDataFrame",

 #' @rdname EndSequenceData-class

 #' @export

 End5SequenceDataFrame <- function(df, ranges, sequence, replicate,

-                                  condition){

-  .SequenceDataFrame("End5",df, ranges, sequence, replicate, condition)

+                                  condition, bamfiles, seqinfo){

+  .SequenceDataFrame("End5",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname EndSequenceData-class

 #' @export

@@ -69,8 +73,10 @@ setClass(Class = "End3SequenceDataFrame",

          contains = "SequenceDataFrame")

 #' @rdname EndSequenceData-class

 #' @export

-End3SequenceDataFrame <- function(df, ranges, sequence, replicate, condition){

-  .SequenceDataFrame("End3",df, ranges, sequence, replicate, condition)

+End3SequenceDataFrame <- function(df, ranges, sequence, replicate, condition,

+                                  bamfiles, seqinfo){

+  .SequenceDataFrame("End3",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname EndSequenceData-class

 #' @export

@@ -84,8 +90,10 @@ setClass(Class = "End3SequenceData",

 #' @rdname EndSequenceData-class

 #' @export

-EndSequenceDataFrame <- function(df, ranges, sequence, replicate, condition){

-  .SequenceDataFrame("End",df, ranges, sequence, replicate, condition)

+EndSequenceDataFrame <- function(df, ranges, sequence, replicate, condition,

+                                 bamfiles, seqinfo){

+  .SequenceDataFrame("End",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname EndSequenceData-class

 #' @export

@@ -120,6 +128,10 @@ EndSequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

                     sequences = sequences, seqinfo = seqinfo, ...)

 }

+setSequenceDataCoercions("End5")

+setSequenceDataCoercions("End3")

+setSequenceDataCoercions("End")

+

 # End5SequenceData ------------------------------------------------------------------

 .summarize_to_position_data <- function(data, hits, names, strands, type){

@@ -259,7 +271,7 @@ setMethod("getData",

 .aggregate_list_data_mean_sd <- function(x, condition){

   conditions <- conditions(x)

   f <- .subset_to_condition(conditions, condition)

-  df <- as(unlist(x,use.names=FALSE),"DataFrame")

+  df <- as(unlist(x,use.names=FALSE),"DataFrame")[,f,drop=FALSE]

   conditions_u <- unique(conditions[f])

   # set up some base values. replicates is here the same as the number of

   # columns, since a list per replicate is assumed

@@ -31,6 +31,9 @@ NULL

 #' transcript name. Must be a name of \code{ranges(x)}

 #' @param condition For \code{\link{aggregate}}: condition for which the data 

 #' should be aggregated.

+#' @param df,ranges,sequence,replicate inputs for creating a 

+#' \code{SequenceDataFrame}. See 

+#' \code{\link[=SequenceDataFrame-class]{SequenceDataFrame}}.

 #' 

 #' @return a \code{NormEnd5SequenceData} or \code{NormEnd3SequenceData} object

 #' 

@@ -54,8 +57,9 @@ setClass(Class = "NormEnd5SequenceDataFrame",

 #' @rdname NormEndSequenceData-class

 #' @export

 NormEnd5SequenceDataFrame <- function(df, ranges, sequence, replicate,

-                                      condition){

-  .SequenceDataFrame("NormEnd5",df, ranges, sequence, replicate, condition)

+                                      condition, bamfiles, seqinfo){

+  .SequenceDataFrame("NormEnd5",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname NormEndSequenceData-class

 #' @export

@@ -74,8 +78,9 @@ setClass(Class = "NormEnd3SequenceDataFrame",

 #' @rdname NormEndSequenceData-class

 #' @export

 NormEnd3SequenceDataFrame <- function(df, ranges, sequence, replicate,

-                                      condition){

-  .SequenceDataFrame("NormEnd3",df, ranges, sequence, replicate, condition)

+                                      condition, bamfiles, seqinfo){

+  .SequenceDataFrame("NormEnd3",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname NormEndSequenceData-class

 #' @export

@@ -100,6 +105,9 @@ NormEnd3SequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

                     sequences = sequences, seqinfo = seqinfo, ...)

 }

+setSequenceDataCoercions("NormEnd5")

+setSequenceDataCoercions("NormEnd3")

+

 # summary ----------------------------------------------------------------------

 .get_summary_MultiColSequenceData <- function(object){

@@ -246,7 +254,7 @@ setMethod("getData",

 .aggregate_data_frame_mean_sd <- function(x, condition){

   conditions <- conditions(x)

   f <- .subset_to_condition(conditions, condition)

-  df <- as(unlist(x,use.names=FALSE)[,f],"DataFrame")

+  df <- as(unlist(x,use.names=FALSE),"DataFrame")[,f,drop=FALSE]

   conditions_u <- unique(conditions[f])

   replicates <- replicates(x)[f]

   # set up some base values

@@ -28,6 +28,9 @@ NULL

 #' transcript name. Must be a name of \code{ranges(x)}

 #' @param condition For \code{\link{aggregate}}: condition for which the data 

 #' should be aggregated.

+#' @param df,ranges,sequence,replicate inputs for creating a 

+#' \code{SequenceDataFrame}. See 

+#' \code{\link[=SequenceDataFrame-class]{SequenceDataFrame}}.

 #' 

 #' @return a \code{PileupSequenceData} object

 #' 

@@ -48,8 +51,10 @@ setClass(Class = "PileupSequenceDataFrame",

          contains = "SequenceDataFrame")

 #' @rdname PileupSequenceData-class

 #' @export

-PileupSequenceDataFrame <- function(df, ranges, sequence, replicate, condition){

-  .SequenceDataFrame("Pileup", df, ranges, sequence, replicate, condition)

+PileupSequenceDataFrame <- function(df, ranges, sequence, replicate, condition,

+                                    bamfiles, seqinfo){

+  .SequenceDataFrame("Pileup", df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname PileupSequenceData-class

 #' @export

@@ -68,6 +73,8 @@ PileupSequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

                sequences = sequences, seqinfo = seqinfo, ...)

 }

+setSequenceDataCoercions("Pileup")

+

 # PileupSequenceData ----------------------------------------------------------------

 .fill_up_pileup_data <- function(pileup,grl,irl){

@@ -180,7 +187,7 @@ setMethod("summary",

 .aggregate_data_frame_percentage_mean_sd <- function(x,condition){

   conditions <- conditions(x)

   f <- .subset_to_condition(conditions, condition)

-  df <- as(unlist(x,use.names=FALSE)[,f],"DataFrame")

+  df <- as(unlist(x,use.names=FALSE),"DataFrame")[,f,drop=FALSE]

   conditions_u <- unique(conditions[f])

   replicates <- replicates(x)[f]

   # set up some base values

@@ -370,12 +377,13 @@ setGeneric(name = "pileupToCoverage",

            def = function(x) standardGeneric("pileupToCoverage"))

 .aggregate_pile_up_to_coverage <- function(data){

-  unlisted_data <- unlist(data)

-  replicates <- unique(replicates(data))

+  unlisted_data <- unlist(data,use.names=FALSE)

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

+                                              replicates(data))))

   ans  <- IRanges::IntegerList(

     lapply(seq_along(replicates),

            function(i){

-             rowSums(as.data.frame(unlisted_data[,replicates(data) == i]))

+             rowSums(as.data.frame(unlisted_data[,replicates == i]))

            }))

   names(ans) <- paste0("replicate.",replicates)

   ans <- do.call(S4Vectors::DataFrame,ans)

@@ -38,6 +38,9 @@ RNAMODR_PROT_SEQDATA_PLOT_DATA_COLOURS <- c(means = "#FBB4AE",

 #' transcript name. Must be a name of \code{ranges(x)}

 #' @param condition For \code{\link{aggregate}}: condition for which the data 

 #' should be aggregated.

+#' @param df,ranges,sequence,replicate inputs for creating a 

+#' \code{SequenceDataFrame}. See 

+#' \code{\link[=SequenceDataFrame-class]{SequenceDataFrame}}.

 #' 

 #' @return a \code{ProtectedEndSequenceData} object

 #' 

@@ -61,8 +64,9 @@ setClass(Class = "ProtectedEndSequenceDataFrame",

 #' @rdname ProtectedEndSequenceData-class

 #' @export

 ProtectedEndSequenceDataFrame <- function(df, ranges, sequence, replicate,

-                                          condition){

-  .SequenceDataFrame("ProtectedEnd",df, ranges, sequence, replicate, condition)

+                                          condition, bamfiles, seqinfo){

+  .SequenceDataFrame("ProtectedEnd",df, ranges, sequence, replicate, condition,

+                     bamfiles, seqinfo)

 }

 #' @rdname ProtectedEndSequenceData-class

 #' @export

@@ -82,6 +86,8 @@ ProtectedEndSequenceData <- function(bamfiles, annotation, sequences, seqinfo,

                sequences = sequences, seqinfo = seqinfo, ...)

 }

+setSequenceDataCoercions("ProtectedEnd")

+

 # ProtectedEndSequenceData -----------------------------------------------------

 #' @rdname ProtectedEndSequenceData-class

@@ -96,10 +96,12 @@ NULL

       }

     }

   }

+  levels <- unique(coord$Parent)

+  # coord <- coord[order(start(coord))]

   if(merge){

-    coord <- split(coord, factor(coord$Parent, levels = unique(coord$Parent)))

+    coord <- split(coord, factor(coord$Parent, levels = levels))

   } else {

-    coord <- coord[order(factor(coord$Parent,unique(coord$Parent)))]

+    coord <- coord[order(factor(coord$Parent, levels = levels))]

     coord <- split(coord, seq_along(coord))

     names(coord) <- mcols(coord, level="within")[,"Parent"]

   }

@@ -216,7 +218,9 @@ NULL

   # converts everything to a GRangesList

   coord <- .norm_coord(coord, args[["type"]], args[["merge"]])

   if(args[["rawData"]]){

-    data <- .norm_sequence_data(as(x,"SplitDataFrameList"))

+    data <- relist(as(unlist(x, use.names = FALSE),"DataFrame"),

+                   IRanges::PartitioningByWidth(x))

+    data <- .norm_sequence_data(data)

   } else {

     data <- .norm_aggregate_data(aggregate(x))

   }

@@ -350,7 +354,8 @@ setMethod("subsetByCoord",

   # converts everything to a GRangesList

   coord <- .norm_coord(coord, args[["type"]])

   if(args[["rawData"]]){

-    data <- as(x,"SplitDataFrameList")

+    data <- relist(as(unlist(x, use.names = FALSE),"DataFrame"),

+                   IRanges::PartitioningByWidth(x))

   } else {

     data <- aggregate(x)

   }

@@ -58,21 +58,11 @@ NULL

 #' Subsetting of a \code{SequenceDataFrame} returns a \code{SequenceDataFrame} or 

 #' \code{DataFrame}, if it is subset by a column or row, respectively. The 

 #' \code{drop} argument is ignored for column subsetting.

-#' 

-#' @param df the data as a \code{DataFrame}.

-#' @param ranges a \code{GRanges} object containing all annotation elements

-#' for a transcript.

-#' @param sequence \code{XString} object describing the nucleotide sequence of 

-#' the transcript.

-#' @param condition The condition of each column or set of columns. Either 

-#' \code{control} or \code{treated}.

-#' @param replicate The replicate of each column or set of columns for the 

-#' individual conditions

-#' @param x,i,j,...,drop arguments used for 

-#' \code{\link[S4Vectors:DataFrame-class]{subsetting}}.

-#' 

-#' @return a \code{SequenceDataFrame} object

-#' 

+#'

+#' @param x,i,j,...,drop,deparse.level arguments used for 

+#' \code{\link[S4Vectors:DataFrame-class]{subsetting}} or 

+#' \code{\link[base:cbind]{base::cbind}}.

+#'

 #' @examples 

 #' data(e5sd,package="RNAmodR")

 #' # A SequenceDataFrame can is usually constructed by subsetting from 

@@ -89,11 +79,15 @@ setClass(Class = "SequenceDataFrame",

          slots = c(ranges = "GRanges",

                    sequence = "XString",

                    condition = "factor",

-                   replicate = "factor"),

+                   replicate = "factor",

+                   bamfiles = "BamFileList",

+                   seqinfo = "Seqinfo"),

          prototype = list(ranges = GRanges(),

                           sequence = RNAString(),

                           condition = factor(),

-                          replicate = factor()))

+                          replicate = factor(),

+                          bamfiles = Rsamtools::BamFileList(),

+                          seqinfo = GenomeInfoDb::Seqinfo()))

 setMethod("relistToClass", "SequenceDataFrame",

           function(x) gsub("DataFrame","Data",class(x))

@@ -112,7 +106,7 @@ sequenceDataFrameClass <- function(dataType){

 }

 .SequenceDataFrame <- function(class, df, ranges, sequence, replicate,

-                               condition){

+                               condition, bamfiles, seqinfo){

   # defaults from function are strangly not set

   if(missing(df)){

     df <- DataFrame()

@@ -129,6 +123,12 @@ sequenceDataFrameClass <- function(dataType){

   if(missing(condition)){

     condition <- factor()

   }

+  if(missing(bamfiles)){

+    bamfiles <- Rsamtools::BamFileList()

+  }

+  if(missing(seqinfo)){

+    seqinfo <- GenomeInfoDb::Seqinfo()

+  }

   # check inputs

   if(!is(df,"DataFrame")){

     stop("Invalid data object: ", class(df), " found, DataFrame expected.")

@@ -149,6 +149,8 @@ sequenceDataFrameClass <- function(dataType){

       sequence = sequence,

       condition = condition,

       replicate = replicate,

+      bamfiles = bamfiles,

+      seqinfo = seqinfo,

       rownames = df@rownames,

       nrows = df@nrows,

       listData = df@listData,

@@ -208,6 +210,18 @@ setMethod(

   f = "conditions", 

   signature = signature(object = "SequenceDataFrame"),

   definition = function(object){object@condition})

+#' @rdname SequenceData-functions

+#' @export

+setMethod(

+  f = "bamfiles", 

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

+  definition = function(x){x@bamfiles})

+#' @rdname SequenceData-functions

+#' @export

+setMethod(

+  f = "seqinfo", 

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

+  definition = function(x){x@seqinfo})

 # internals --------------------------------------------------------------------

@@ -249,6 +263,61 @@ setMethod(

   }

 )

+#' @rdname SequenceDataFrame-class

+#' @export

+setMethod(

+  "cbind", "SequenceDataFrame",