@@ -2,20 +2,27 @@

 export("settings<-")

 export(CoverageSequenceData)

+export(CoverageSequenceDataFrame)

 export(End3SequenceData)

+export(End3SequenceDataFrame)

 export(End5SequenceData)

+export(End5SequenceDataFrame)

 export(EndSequenceData)

+export(EndSequenceDataFrame)

 export(ModInosine)

 export(ModRNASequenceTrack)

 export(ModSetInosine)

 export(Modifier)

 export(ModifierSet)

 export(NormEnd3SequenceData)

+export(NormEnd3SequenceDataFrame)

 export(NormEnd5SequenceData)

+export(NormEnd5SequenceDataFrame)

 export(PileupSequenceData)

+export(PileupSequenceDataFrame)

 export(ProtectedEndSequenceData)

+export(ProtectedEndSequenceDataFrame)

 export(RNASequenceTrack)

-export(SequenceDataFrame)

 export(SequenceDataList)

 export(SequenceDataSet)

 export(aggregate)

@@ -49,18 +56,26 @@ export(subsetByCoord)

 export(validAggregate)

 export(validModification)

 exportClasses(CoverageSequenceData)

+exportClasses(CoverageSequenceDataFrame)

 exportClasses(End3SequenceData)

+exportClasses(End3SequenceDataFrame)

 exportClasses(End5SequenceData)

+exportClasses(End5SequenceDataFrame)

 exportClasses(EndSequenceData)

+exportClasses(EndSequenceDataFrame)

 exportClasses(ModInosine)

 exportClasses(ModRNASequenceTrack)

 exportClasses(ModSetInosine)

 exportClasses(Modifier)

 exportClasses(ModifierSet)

 exportClasses(NormEnd3SequenceData)

+exportClasses(NormEnd3SequenceDataFrame)

 exportClasses(NormEnd5SequenceData)

+exportClasses(NormEnd5SequenceDataFrame)

 exportClasses(PileupSequenceData)

+exportClasses(PileupSequenceDataFrame)

 exportClasses(ProtectedEndSequenceData)

+exportClasses(ProtectedEndSequenceDataFrame)

 exportClasses(RNASequenceTrack)

 exportClasses(SequenceDataFrame)

 exportClasses(SequenceDataList)

@@ -140,8 +155,13 @@ importFrom(GenomicFeatures,makeTxDbFromGFF)

 importFrom(Gviz,AnnotationTrack)

 importFrom(Gviz,DataTrack)

 importFrom(Gviz,plotTracks)

+importFrom(IRanges,CharacterList)

+importFrom(IRanges,IRanges)

+importFrom(IRanges,IntegerList)

+importFrom(IRanges,LogicalList)

 importFrom(IRanges,PartitioningByEnd)

 importFrom(IRanges,PartitioningByWidth)

+importFrom(IRanges,SplitDataFrameList)

 importFrom(IRanges,splitAsList)

 importFrom(Modstrings,ModRNAString)

 importFrom(Modstrings,ModRNAStringSet)

@@ -283,7 +283,7 @@ setClass("Modifier",

   }

   if(hasAggregateData(x)){

     data <- getAggregateData(x)

-    if(is.null(rownames(data@unlistData))){

+    if(is.null(rownames(unlist(data, use.names = FALSE)))){

       return("rownames of aggregate data is not set.")

     } else {

       seqs <- .seqs_rl_strand(ranges(x))

@@ -871,7 +871,7 @@ NULL

 .check_aggregate_modifier <- function(data, x){

   score <- x@score

   if(is(data,"CompressedSplitDataFrameList")){

-    columns <- colnames(data@unlistData)

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

   } else {

     stop("aggregate data has to be a 'CompressedSplitDataFrameList' object. ",

          "Contact the maintainer of the class used.",

@@ -22,14 +22,15 @@ NULL

 }

 .get_data_stats <- function(object){

-  stats <- lapply(seq_len(ncol(object@unlistData)),

+  unlisted_object <- unlist(object, use.names = FALSE)

+  stats <- lapply(seq_len(ncol(unlisted_object)),

                   function(i){

-                    as.data.frame(as.list(summary(object@unlistData[,i])))

+                    as.data.frame(as.list(summary(unlisted_object[,i])))

                   })

   stats <- Reduce(rbind,stats)

   stats <- as.data.frame(t(stats),

                          stringsAsFactors = FALSE)

-  colnames(stats) <- colnames(object@unlistData)

+  colnames(stats) <- colnames(unlisted_object)

   rownames(stats) <- paste0("Data.",rownames(stats))

   stats

 }

@@ -73,7 +73,9 @@ NULL

 #' @importFrom Modstrings ModRNAString ModRNAStringSet combineIntoModstrings

 #' shortName fullName

 #' @importClassesFrom IRanges IntegerList CharacterList LogicalList IRanges

-#' SplitDataFrameList

+#' SplitDataFrameList PartitioningByEnd PartitioningByWidth

+#' @importFrom IRanges IntegerList CharacterList LogicalList IRanges

+#' SplitDataFrameList PartitioningByEnd PartitioningByWidth

 NULL

 # constants for annotation -----------------------------------------------------

@@ -95,20 +95,14 @@ NULL

 setClass("SequenceData",

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

-         slots = c(ranges = "GRangesList",

-                   sequences = "XStringSet",

-                   sequencesType = "character",

+         slots = c(sequencesType = "character",

                    bamfiles = "BamFileList",

-                   condition = "factor",

-                   replicate = "factor",

                    seqinfo = "Seqinfo",

                    minQuality = "integer",

+                   unlistData = "SequenceDataFrame",

                    unlistType = "character",

                    dataDescription = "character"),

-         prototype = list(ranges = GRangesList(),

-                          sequencesType = "RNAStringSet",

-                          sequences = RNAStringSet(),

-                          unlistType = "SequenceDataFrame"))

+         prototype = list(sequencesType = "RNAStringSet"))

 setMethod(

   f = "initialize",

@@ -131,22 +125,17 @@ sequenceDataClass <- function(dataType){

   if(is(tmp,"try-error")){

     stop("Class '",ans,"' not found: ",tmp)

   }

-  

   ans

 }

-# for concat

-#' @rdname RNAmodR-internals

-setMethod("parallelSlotNames", "SequenceData",

-          function(x) c("ranges","sequences", callNextMethod())

-)

-

 #' @rdname SequenceData-functions

 setMethod("show", "SequenceData",

   function(object){

     k <- length(object)

-    data_nc <- ncol(object@unlistData)

-    ranges_mcols <- mcols(object@ranges@unlistData, use.names = FALSE)

+    unlisted_object <- object@unlistData

+    data_nc <- ncol(unlisted_object)

+    unlisted_ranges <- unlist(ranges(object),use.names = FALSE)

+    ranges_mcols <- mcols(unlisted_ranges, use.names = FALSE)

     ranges_nmc <- if (is.null(ranges_mcols)) 0L else ncol(ranges_mcols)

     cat(classNameForDisplay(object), " with ", k, " elements ",

         "containing ",sep = "")

@@ -157,9 +146,9 @@ setMethod("show", "SequenceData",

     out_data <- NULL

     # data

     if (data_nc > 0) {

-      data_col_names <- colnames(object@unlistData)

+      data_col_names <- colnames(unlisted_object)

       data_col_types <- 

-        lapply(object@unlistData, function(x) {

+        lapply(unlisted_object, function(x) {

           paste0("<", classNameForDisplay(x)[1],">")

         })

       out_data <- 

@@ -168,21 +157,22 @@ setMethod("show", "SequenceData",

     }

     cat("- Data columns:\n")

     print(out_data, quote = FALSE, right = TRUE)

-    cat("-  ",class(object@seqinfo), " object with ", 

-        summary(object@seqinfo), ":\n", sep = "")

+    cat("-  ",class(seqinfo(object)), " object with ", 

+        summary(seqinfo(object)), ":\n", sep = "")

   }

 )

 # validity ---------------------------------------------------------------------

 .valid.SequenceData_elements <- function(x){

-  nrow <- sum(unlist(width(ranges(x))))

-  if(nrow != nrow(x@unlistData)){

+  unlisted_x <- unlist(x, use.names=FALSE)

+  nrow <- sum(width(ranges(unlisted_x)))

+  if(nrow != nrow(unlisted_x)){

     return("row number of data does not match position covered by annotation.")

   }

-  if(nrow != sum(width(x@sequences))){

+  if(nrow != sum(width(sequences(x)))){

     return("Length of sequences does not match position covered by annotation.")

   }

-  if(is.null(rownames(x@unlistData))){

+  if(is.null(rownames(unlisted_x))){

     return("rownames of data is not set.")

   } else {

     seqs <- .seqs_rl_strand(ranges(x))

@@ -200,100 +190,16 @@ setMethod("show", "SequenceData",

 }

 S4Vectors::setValidity2(Class = "SequenceData", .valid.SequenceData)

-# replacing --------------------------------------------------------------------

+# coercion ---------------------------------------------------------------------

-#' @rdname RNAmodR-internals

-setReplaceMethod("[", "SequenceData",

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

-    if (length(list(...)) > 0L){

-      stop("invalid replacement")

-    }

-    if(!missing(j)){

-      stop("replacement of columns not supported")

-    }

-    if(!is(value,class(x))){

-      stop("replacement 'value' must be of the same class than 'x'")

-    }

-    if (missing(i)){

-      x <- value

-    } else {

-      if(length(i) != length(value)){

-        warning("number of items to replace is not a multiple of replacement ",

-                "length")

-        value <- value[seq_along(i)]

-      }

-      x@ranges[i] <- ranges(value)

-      names(x@ranges)[i] <- names(ranges(value)) # must be set explicitly

-      x@sequences[i] <- sequences(value)

-      names(x@sequences)[i] <- names(sequences(value)) # must be set explicitly

-      # rownames needs to be savid since a replace removes them

-      rownames <- rownames(x)

-      rownames[i] <- rownames(value)

-      tmp <- callNextMethod(x = as(x,"SplitDataFrameList"), i = i,

-                            value = as(value,"SplitDataFrameList"))

-      x@unlistData <- tmp@unlistData

-      x@partitioning <- tmp@partitioning

-      rownames(x) <- rownames

-    }

-    validObject(x)

-    return(x)

-  }

-)

-

-#' @rdname RNAmodR-internals

-setMethod("setListElement", "SequenceData",

-  function(x, i, value){

-    if(!is(value,"SequenceDataFrame")){

-      stop("invalid value. must be 'SequenceDataFrame'.")

-    }

-    i2 <- S4Vectors::normalizeDoubleBracketSubscript(i, x, allow.append = TRUE,

-                                                     allow.nomatch = TRUE)

-    if(any(colnames(value) != colnames(unlist(x, use.names=FALSE)))){

-      stop("'value' does not have matching colnames.")

-    }

-    x@ranges[[i2]] <- ranges(value)

-    x@sequences[[i2]] <- sequences(value)

-    # rownames needs to be savid since a replace removes them

-    rownames <- rownames(x)

-    rownames[[i2]] <- rownames(value)

-    tmp <- callNextMethod(x = as(x,"SplitDataFrameList"), i = i,

-                          value = as(value,"DataFrame"))

-    x@unlistData <- tmp@unlistData

-    x@partitioning <- tmp@partitioning

-    rownames(x) <- rownames

-    validObject(x)

-    x

-  }

-)

-

-# looping ----------------------------------------------------------------------

-

-#' @importFrom IRanges PartitioningByEnd

-lapply_SequenceData <- function(X, FUN, ...){

-  FUN <- match.fun(FUN)

-  ans <- vector(mode = "list", length = length(X))

-  X_partitioning <- IRanges::PartitioningByEnd(X)

-  X_elt_width <- width(X_partitioning)

-  empty_idx <- which(X_elt_width == 0L)

-  if (length(empty_idx) != 0L){

-    ans[empty_idx] <- NULL

-  }

-  non_empty_idx <- which(X_elt_width != 0L)

-  if (length(non_empty_idx) == 0L){

-    return(ans)

-  }

-  ans[non_empty_idx] <- 

-    lapply(non_empty_idx, function(i){ FUN(getListElement(X,i), ...) })

-  ans

+.as_SplitDataFrameList <- function(from){

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

+         IRanges::PartitioningByWidth(from))

 }

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

-setMethod("lapply", "SequenceData",

-  function(X, FUN, ...){

-    ans <- lapply_SequenceData(X, FUN, ...)

-    names(ans) <- names(X)

-    ans

-  }

-)

+

+# internals --------------------------------------------------------------------

 #' @importClassesFrom IRanges PartitioningByEnd

 #' @importFrom IRanges PartitioningByEnd

@@ -312,44 +218,36 @@ setMethod("extractROWS", "SequenceData",

     idx_on_unlisted_x <- 

       IRanges::IRanges(end = extractROWS(end(IRanges::PartitioningByEnd(x)), i),

                        width = ans_eltNROWS)

-    ans_unlistData <- extractROWS(x@unlistData, idx_on_unlisted_x)

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

-                             NAMES = extractROWS(names(x), i), check = FALSE)

+    ans_unlistData <- extractROWS(unlist(x,use.names = FALSE),

+                                  idx_on_unlisted_x)

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

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

     ans_elementMetadata <- extractROWS(x@elementMetadata, i)

-    ans_ranges <- extractROWS(x@ranges, i)

-    ans_sequences <- extractROWS(x@sequences, i)

-    initialize(x, ranges = ans_ranges, sequences = ans_sequences,

-               replicate = x@replicate, condition = x@condition,

-               bamfiles = x@bamfiles, seqinfo = x@seqinfo, 

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

                minQuality = x@minQuality, unlistData = ans_unlistData,

                partitioning = ans_partitioning, 

                elementMetadata = ans_elementMetadata)

   }

 )

-#' @rdname RNAmodR-internals

-#' @importFrom IRanges PartitioningByEnd

-setMethod("getListElement", "SequenceData",

-  function(x, i, exact=TRUE){

-    i2 <- normalizeDoubleBracketSubscript(i, x, exact = exact,

-                                          allow.NA = TRUE,

-                                          allow.nomatch = TRUE)

-    if (is.na(i2)){

-      return(NULL)

-    }

-    unlisted_x <- unlist(x, use.names = FALSE)

-    x_partitioning <- IRanges::PartitioningByEnd(x)

-    window_start <- start(x_partitioning)[i2]

-    window_end <- end(x_partitioning)[i2]

-    new(x@unlistType,

-        S4Vectors:::Vector_window(unlisted_x,

-                                  start = window_start,

-                                  end = window_end),

-        ranges = x@ranges[[i2]],

-        sequence = x@sequences[[i2]],

-        condition = x@condition,

-        replicate = x@replicate)

-  }

+setMethod("rownames", "SequenceData",

+          function (x){

+            ans <- rownames(unlist(x,use.names = FALSE), do.NULL = TRUE)

+            relist(ans,x)

+          }

+)

+

+# 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, ...)

+          }

 )

@@ -359,7 +257,7 @@ setMethod("cbind", "SequenceData",

           function(...){

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

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

-          }

+  }

 )

 setMethod("rbind", "SequenceData",

           function(...){

@@ -368,26 +266,6 @@ setMethod("rbind", "SequenceData",

           }

 )

-# unlisting --------------------------------------------------------------------

-

-setMethod("unlist", "SequenceData",

-          function(x, recursive=TRUE, use.names=TRUE){

-            if (!isTRUEorFALSE(use.names)){

-              stop("'use.names' must be TRUE or FALSE")

-            }

-            unlisted_x <- x@unlistData

-            if (use.names){

-              unlisted_x <- S4Vectors:::set_unlisted_names(unlisted_x, x)

-            }

-            new(x@unlistType,

-                unlisted_x,

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

-                sequence = unlist(sequences(x)),

-                condition = x@condition,

-                replicate = x@replicate)

-          }

-)

-

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

 .quality_settings <- data.frame(

@@ -538,24 +416,25 @@ setMethod("unlist", "SequenceData",

      any(names(ranges) != names(data))){

     stop("")

   }

-  message("OK")

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

   # Create SequenceData object

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

-  new2(className, 

-       ranges = ranges,

-       sequences = sequences,

-       bamfiles = bamfiles, 

-       condition = condition,

-       replicate = replicate,

-       seqinfo = seqinfo,

-       minQuality = minQuality,

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

-       partitioning = IRanges::PartitioningByEnd(data),

-       ...)

+  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),

+             partitioning = IRanges::PartitioningByEnd(data),

+             ...)

+  message("OK")

+  ans

 }

-

 .SequenceData_settings <- data.frame(

   variable = c("max_depth",

                "minLength",

@@ -603,10 +482,18 @@ setMethod("unlist", "SequenceData",

   # get annotation and sequence data

   annotation <- .norm_annotation(annotation, className)

   sequences <- .norm_sequences(sequences, className)

+  seqinfo_missing <- missing(seqinfo)

   seqinfo <- .norm_seqnames(bamfiles, annotation, sequences, seqinfo, className)

   # load transcript data and sequence data

   grl <- .load_annotation(annotation)

   grl <- .subset_by_seqinfo(grl, seqinfo)

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

+    if(seqinfo_missing){

+      stop("No overlap between bamfiles and annotation.")

+    } else {

+      stop("No overlap between bamfiles, annotation and seqinfo.")

+    }

+  }

   sequences <- .load_transcript_sequences(sequences, grl)

   # create the class

   .SequenceData(className, bamfiles, grl, sequences, seqinfo, args)

@@ -777,17 +664,29 @@ setMethod(f = "bamfiles",

 #' @export

 setMethod(f = "conditions", 

           signature = signature(object = "SequenceData"),

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

+          definition = function(object){conditions(unlist(object))})

 #' @rdname SequenceData-functions

 #' @export

-setMethod(f = "ranges", 

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

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

+setMethod(

+  f = "ranges", 

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

+  definition = 

+    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)

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

+        stop("ranges could not be relisted.")

+      }

+      relist(unlisted_ranges, partitioning_relist)

+    })

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "replicates", 

           signature = signature(x = "SequenceData"),

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

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

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "seqinfo", 

@@ -797,7 +696,7 @@ setMethod(f = "seqinfo",

 #' @export

 setMethod(f = "sequences", 

           signature = signature(x = "SequenceData"),

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

+          definition = function(x){relist(sequences(unlist(x)),x)})

 # dummy functions --------------------------------------------------------------

 # this needs to be implemented by each subclass

@@ -39,18 +39,31 @@ NULL

 #'                             sequences = sequences)

 NULL

+

+#' @rdname CoverageSequenceData-class

+#' @export

+setClass(Class = "CoverageSequenceDataFrame",

+         contains = "SequenceDataFrame")

+#' @rdname CoverageSequenceData-class

+#' @export

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

+                                      condition){

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

+}

 #' @rdname CoverageSequenceData-class

 #' @export

 setClass(Class = "CoverageSequenceData",

          contains = "SequenceData",

-         prototype = list(minQuality = 5L,

+         slots = c(unlistData = "CoverageSequenceDataFrame"),

+         prototype = list(unlistData = CoverageSequenceDataFrame(),

+                          unlistType = "CoverageSequenceDataFrame",

+                          minQuality = 5L,

                           dataDescription = "Coverage data"))

-

 #' @rdname CoverageSequenceData-class

 #' @export

 CoverageSequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

-  SequenceData("Coverage", bamfiles = bamfiles, annotation = annotation,

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

+  .new_SequenceData("Coverage", bamfiles = bamfiles, annotation = annotation,

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

 }

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

@@ -142,7 +155,7 @@ setMethod(

     # clean meta data columns

     seqdata <- .clean_mcols_coverage(seqdata)

     seqdata <- unlist(seqdata)

-    conditions <- unique(x@condition)

+    conditions <- unique(conditions(x))

     if("control" %in% conditions){

       d <- seqdata[,stringr::str_detect(colnames(mcols(seqdata)),"control")]

       colnames(mcols(d)) <- gsub(".control","",colnames(mcols(d)))

@@ -43,47 +43,83 @@ NULL

 #'                         sequences = sequences)

 NULL

+#' @rdname EndSequenceData-class

+#' @export

+setClass(Class = "End5SequenceDataFrame",

+         contains = "SequenceDataFrame")

+#' @rdname EndSequenceData-class

+#' @export

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

+                                  condition){

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

+}

 #' @rdname EndSequenceData-class

 #' @export

 setClass(Class = "End5SequenceData",

          contains = "SequenceData",

-         prototype = list(minQuality = 5L,

+         slots = c(unlistData = "End5SequenceDataFrame"),

+         prototype = list(unlistData = End5SequenceDataFrame(),

+                          unlistType = "End5SequenceDataFrame",

+                          minQuality = 5L,

                           dataDescription = "5'-end position data"))

+#' @rdname EndSequenceData-class

+#' @export

+setClass(Class = "End3SequenceDataFrame",

+         contains = "SequenceDataFrame")

+#' @rdname EndSequenceData-class

+#' @export

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

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

+}

 #' @rdname EndSequenceData-class

 #' @export

 setClass(Class = "End3SequenceData",

          contains = "SequenceData",

-         prototype = list(minQuality = 5L,

+         slots = c(unlistData = "End3SequenceDataFrame"),

+         prototype = list(unlistData = End3SequenceDataFrame(),

+                          unlistType = "End3SequenceDataFrame",

+                          minQuality = 5L,

                           dataDescription = "3'-end position data"))

 #' @rdname EndSequenceData-class

 #' @export

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

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

+}

+#' @rdname EndSequenceData-class

+#' @export

+setClass(Class = "EndSequenceDataFrame",

+         contains = "SequenceDataFrame")

+#' @rdname EndSequenceData-class

+#' @export

 setClass(Class = "EndSequenceData",

          contains = "SequenceData",

-         prototype = list(minQuality = 5L,

+         slots = c(unlistData = "EndSequenceDataFrame"),

+         prototype = list(unlistData = EndSequenceDataFrame(),

+                          unlistType = "EndSequenceDataFrame",

+                          minQuality = 5L,

                           dataDescription = "read end position data (5' and 3')"))

 #' @rdname EndSequenceData-class

 #' @export

 End5SequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

-  SequenceData("End5", bamfiles = bamfiles, annotation = annotation,

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

+  .new_SequenceData("End5", bamfiles = bamfiles, annotation = annotation,

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

 }

 #' @rdname EndSequenceData-class

 #' @export

 End3SequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

-  SequenceData("End3", bamfiles = bamfiles, annotation = annotation,

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

+  .new_SequenceData("End3", bamfiles = bamfiles, annotation = annotation,

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

 }

 #' @rdname EndSequenceData-class

 #' @export

 EndSequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

-  SequenceData("End", bamfiles = bamfiles, annotation = annotation,

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

+  .new_SequenceData("End", bamfiles = bamfiles, annotation = annotation,

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

 }

-

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

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

@@ -221,27 +257,28 @@ setMethod("getData",

 #' @importFrom matrixStats rowSds

 .aggregate_list_data_mean_sd <- function(x, condition){

-  f <- .subset_to_condition(x@condition, condition)

-  df <- x@unlistData[f]

-  conditions <- unique(x@condition[f])

+  conditions <- conditions(x)

+  f <- .subset_to_condition(conditions, condition)

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

+  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

   # get means

   means <- IRanges::NumericList(

-    lapply(conditions,

+    lapply(conditions_u,

            function(con){

-             rowMeans(as.data.frame(df[,x@condition[f] == con]),

+             rowMeans(as.data.frame(df[,conditions[f] == con]),

                       na.rm = TRUE)

            }))

-  names(means) <- paste0("means.", conditions)

+  names(means) <- paste0("means.", conditions_u)

   # get sds

   sds <- IRanges::NumericList(

-    lapply(conditions,

+    lapply(conditions_u,

            function(con){

-             matrixStats::rowSds(as.matrix(df[,x@condition[f] == con]),

+             matrixStats::rowSds(as.matrix(df[,conditions[f] == con]),

                                  na.rm = TRUE)

            }))

-  names(sds) <- paste0("sds.", conditions)

+  names(sds) <- paste0("sds.", conditions_u)

   # assemble data

   ans <- cbind(do.call(DataFrame, means),

                do.call(DataFrame, sds))

@@ -306,7 +343,7 @@ setMethod(

     # clean meta data columns

     seqdata <- .clean_mcols_end(seqdata)

     seqdata <- unlist(seqdata)

-    conditions <- unique(x@condition)

+    conditions <- unique(conditions(x))

     if("control" %in% conditions){

       d <- seqdata[,stringr::str_detect(colnames(mcols(seqdata)),"control")]

       colnames(mcols(d)) <- gsub(".control","",colnames(mcols(d)))

@@ -355,7 +392,7 @@ setMethod(

     # clean meta data columns

     seqdata <- .clean_mcols_end(seqdata)

     seqdata <- unlist(seqdata)

-    conditions <- unique(x@condition)

+    conditions <- unique(conditions(x))

     if("control" %in% conditions){

       d <- seqdata[,stringr::str_detect(colnames(mcols(seqdata)),"control")]

       colnames(mcols(d)) <- gsub(".control","",colnames(mcols(d)))

@@ -404,7 +441,7 @@ setMethod(

     # clean meta data columns

     seqdata <- .clean_mcols_end(seqdata)

     seqdata <- unlist(seqdata)

-    conditions <- unique(x@condition)

+    conditions <- unique(conditions(x))

     if("control" %in% conditions){

       d <- seqdata[,stringr::str_detect(colnames(mcols(seqdata)),"control")]

       colnames(mcols(d)) <- gsub(".control","",colnames(mcols(d)))

@@ -47,31 +47,57 @@ NULL

 #' }

 NULL

+#' @rdname NormEndSequenceData-class

+#' @export

+setClass(Class = "NormEnd5SequenceDataFrame",

+         contains = "SequenceDataFrame")

+#' @rdname NormEndSequenceData-class

+#' @export

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

+                                      condition){

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

+}

 #' @rdname NormEndSequenceData-class

 #' @export

 setClass(Class = "NormEnd5SequenceData",

          contains = "SequenceData",

-         prototype = list(minQuality = 5L,

+         slots = c(unlistData = "NormEnd5SequenceDataFrame"),

+         prototype = list(unlistData = NormEnd5SequenceDataFrame(),

+                          unlistType = "NormEnd5SequenceDataFrame",

+                          minQuality = 5L,

                           dataDescription = "normalized 5'-end position data"))

+#' @rdname NormEndSequenceData-class

+#' @export

+setClass(Class = "NormEnd3SequenceDataFrame",

+         contains = "SequenceDataFrame")

+#' @rdname NormEndSequenceData-class

+#' @export

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

+                                      condition){

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

+}

 #' @rdname NormEndSequenceData-class

 #' @export

 setClass(Class = "NormEnd3SequenceData",

          contains = "SequenceData",

-         prototype = list(minQuality = 5L,

+         slots = c(unlistData = "NormEnd3SequenceDataFrame"),

+         prototype = list(unlistData = NormEnd3SequenceDataFrame(),

+                          unlistType = "NormEnd3SequenceDataFrame",

+                          minQuality = 5L,

                           dataDescription = "normalized 3'-end position data"))

 #' @rdname NormEndSequenceData-class

 #' @export

 NormEnd5SequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

-  SequenceData("NormEnd5", bamfiles = bamfiles, annotation = annotation,

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

+  .new_SequenceData("NormEnd5", bamfiles = bamfiles, annotation = annotation,

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

 }

 #' @rdname NormEndSequenceData-class

 #' @export

 NormEnd3SequenceData <- function(bamfiles, annotation, sequences, seqinfo, ...){

-  SequenceData("NormEnd3", bamfiles = bamfiles, annotation = annotation,

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

+  .new_SequenceData("NormEnd3", bamfiles = bamfiles, annotation = annotation,

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

 }

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

@@ -218,12 +244,13 @@ setMethod("getData",

 # - calculate sd per observation

 #' @importFrom matrixStats rowSds

 .aggregate_data_frame_mean_sd <- function(x, condition){

-  f <- .subset_to_condition(x@condition, condition)

-  df <- x@unlistData[f]

-  conditions <- unique(x@condition[f])

-  replicates <- x@replicate[f]

+  conditions <- conditions(x)

+  f <- .subset_to_condition(conditions, condition)

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

+  conditions_u <- unique(conditions[f])

+  replicates <- replicates(x)[f]

   # set up some base values

-  sample_width <- length(replicates[x@condition[f] == conditions[1] & 

+  sample_width <- length(replicates[conditions[f] == conditions_u[1] & 

                                       replicates == unique(replicates)[1]])

   colNames <- strsplit(colnames(df)[seq_len(sample_width)],"\\.")

   colNames <- IRanges::CharacterList(colNames)[as.list(lengths(colNames))]

@@ -232,12 +259,12 @@ setMethod("getData",

   # get means

   means <- do.call(

     c,

-    lapply(conditions,

+    lapply(conditions_u,

            function(con){

-             ff <- x@condition[f] == con

+             ff <- conditions[f] == con

              ncol <- ncol(df[,ff,drop = FALSE]

                           [,replicates[ff] == unique(replicates[ff])[1],

-                             drop = FALSE])

+                            drop = FALSE])

              seqAdd <- seq.int(from = 0, 

                                to = ncol(df[,ff,drop=FALSE]) - 1, 

                                by = sample_width)

@@ -253,9 +280,9 @@ setMethod("getData",

   # get sds

   sds <- do.call(

     c,

-    lapply(conditions,

+    lapply(conditions_u,

            function(con){

-             ff <- x@condition[f] == con

+             ff <- conditions[f] == con

              ncol <- ncol(df[,ff,drop = FALSE]

                           [,replicates[ff] == unique(replicates[ff])[1],

                             drop = FALSE])

@@ -266,7 +293,7 @@ setMethod("getData",

                lapply(seq_len(ncol),

                       function(i){

                         unname(matrixStats::rowSds(as.matrix(df[,ff,drop=FALSE][,i + seqAdd,drop=FALSE]),

-                                        na.rm = TRUE))

+                                                   na.rm = TRUE))

                       }))

              names(means) <- paste0("sds.", con, ".", colNames)

              means

@@ -328,8 +355,8 @@ setMethod(

     # clean meta data columns

     seqdata <- .clean_mcols_normend(seqdata)

     seqdata <- unlist(seqdata)

-    conditions <- unique(x@condition)

-    if("control" %in% conditions){

+    conditions_u <- unique(conditions(x))

+    if("control" %in% conditions_u){

       d <- seqdata[,stringr::str_detect(colnames(mcols(seqdata)),"control")]

       colnames(mcols(d)) <- gsub(".control","",colnames(mcols(d)))

       dt.control.tx <- Gviz::DataTrack(

@@ -357,7 +384,7 @@ setMethod(

       tracks <- list("NormEnd5tx" = dt.control.tx,

                      "NormEnd5ol" = dt.control.ol)

     }

-    if("treated" %in% conditions){

+    if("treated" %in% conditions_u){

       d <- seqdata[,stringr::str_detect(colnames(mcols(seqdata)),"treated")]

       colnames(mcols(d)) <- gsub(".treated","",colnames(mcols(d)))

       dt.treated.tx <- Gviz::DataTrack(

@@ -383,7 +410,7 @@ setMethod(

       tracks <- list("NormEnd5tx" = dt.treated.tx,

                      "NormEnd5ol" = dt.treated.ol)

     }

-    if(length(conditions) == 2L){

+    if(length(conditions_u) == 2L){