@@ -9,6 +9,7 @@ export(End5SequenceData)

 export(End5SequenceDataFrame)

 export(EndSequenceData)

 export(EndSequenceDataFrame)

+export(ModDNASequenceTrack)

 export(ModInosine)

 export(ModRNASequenceTrack)

 export(ModSetInosine)

@@ -58,12 +59,14 @@ export(validAggregate)

 export(validModification)

 exportClasses(CoverageSequenceData)

 exportClasses(CoverageSequenceDataFrame)

+exportClasses(DNAModifier)

 exportClasses(End3SequenceData)

 exportClasses(End3SequenceDataFrame)

 exportClasses(End5SequenceData)

 exportClasses(End5SequenceDataFrame)

 exportClasses(EndSequenceData)

 exportClasses(EndSequenceDataFrame)

+exportClasses(ModDNASequenceTrack)

 exportClasses(ModInosine)

 exportClasses(ModRNASequenceTrack)

 exportClasses(ModSetInosine)

@@ -77,12 +80,14 @@ exportClasses(PileupSequenceData)

 exportClasses(PileupSequenceDataFrame)

 exportClasses(ProtectedEndSequenceData)

 exportClasses(ProtectedEndSequenceDataFrame)

+exportClasses(RNAModifier)

 exportClasses(RNASequenceTrack)

 exportClasses(SequenceDFrame)

 exportClasses(SequenceDataFrame)

 exportClasses(SequenceDataList)

 exportClasses(SequenceDataSet)

 exportMethods("[")

+exportMethods("seqtype<-")

 exportMethods("settings<-")

 exportMethods(Modifier)

 exportMethods(ModifierSet)

@@ -115,6 +120,7 @@ exportMethods(ranges)

 exportMethods(rbind)

 exportMethods(replicates)

 exportMethods(seqinfo)

+exportMethods(seqtype)

 exportMethods(sequenceData)

 exportMethods(sequences)

 exportMethods(settings)

@@ -143,11 +149,13 @@ importFrom(BiocParallel,SerialParam)

 importFrom(BiocParallel,bplapply)

 importFrom(BiocParallel,bpmapply)

 importFrom(BiocParallel,register)

+importFrom(Biostrings,"seqtype<-")

 importFrom(Biostrings,DNAString)

 importFrom(Biostrings,DNAStringSet)

 importFrom(Biostrings,RNAString)

 importFrom(Biostrings,RNAStringSet)

 importFrom(Biostrings,getSeq)

+importFrom(Biostrings,seqtype)

 importFrom(Biostrings,subseq)

 importFrom(Biostrings,xscat)

 importFrom(GenomeInfoDb,seqnames)

@@ -165,6 +173,8 @@ importFrom(IRanges,LogicalList)

 importFrom(IRanges,PartitioningByEnd)

 importFrom(IRanges,PartitioningByWidth)

 importFrom(IRanges,SplitDataFrameList)

+importFrom(Modstrings,ModDNAString)

+importFrom(Modstrings,ModDNAStringSet)

 importFrom(Modstrings,ModRNAString)

 importFrom(Modstrings,ModRNAStringSet)

 importFrom(Modstrings,combineIntoModstrings)

@@ -197,3 +197,56 @@ ModRNASequenceTrack <- function(sequence, chromosome, genome, ...){

                                       .get_ModRNA_bio_color(),

                                       ...)

 }

+

+################################################################################

+## Gviz + ModDNAString #########################################################

+################################################################################

+

+#' @name ModDNASequenceTrack

+#' @aliases ModDNASequenceTrack-class

+#' 

+#' @title ModDNASequenceTrack

+#' 

+#' @description 

+#' A \code{Gviz} compatible 

+#' \code{\link[Gviz:SequenceTrack-class]{SequenceTrack}} for showing modified 

+#' DNA sequences.

+#' 

+#' @export

+setClass("ModDNASequenceTrack",

+         contains = "ModifiedSequenceTrack",

+         representation = representation(sequence = "ModDNAStringSet",

+                                         chromosome = "character",

+                                         genome = "character"),

+         prototype = prototype(seqType = "ModDNAString",

+                               sequence = ModDNAStringSet(),

+                               name = "Sequence",

+                               chromosome = "chr0",

+                               genome = "all")

+)

+

+#' @rdname ModDNASequenceTrack

+#' 

+#' @param sequence A \code{character} vector or \code{ModDNAString} object of 

+#' length one. The sequence to display. See 

+#' \code{\link[Gviz:SequenceTrack-class]{SequenceTrack}}.

+#' @param chromosome,genome,... See 

+#' \code{\link[Gviz:SequenceTrack-class]{SequenceTrack}}.

+#' 

+#' @return a \code{ModDNASequenceTrack} object

+#'   

+#' @export

+#' 

+#' @examples

+#' seq <- ModDNAStringSet(c(chr1 = paste0(alphabet(ModDNAString()),collapse = "")))

+#' st <- ModDNASequenceTrack(seq)

+#' Gviz::plotTracks(st, chromosome = "chr1",from = 1L, to = 20L)

+ModDNASequenceTrack <- function(sequence, chromosome, genome, ...){

+  .stringSet_to_ModifiedSequenceTrack("ModDNASequenceTrack",

+                                      "ModDNAStringSet",

+                                      sequence,

+                                      chromosome,

+                                      genome,

+                                      .get_ModDNA_bio_color(),

+                                      ...)

+}

@@ -2,6 +2,15 @@

 #' @include Gviz-ModifiedSequenceTrack-class.R

 NULL

+.get_ModDNA_bio_color <- function(){

+  alphabetNames <- alphabet(ModDNAString())

+  alphabet <- rep("#33FF00",length(alphabetNames))

+  names(alphabet) <- alphabetNames

+  dna_color <- getBioColor(type="DNA_BASES_N")

+  alphabet[match(names(dna_color),names(alphabet))] <- dna_color

+  alphabet

+}

+

 .get_ModRNA_bio_color <- function(){

   alphabetNames <- alphabet(ModRNAString())

   alphabet <- rep("#33FF00",length(alphabetNames))

@@ -143,7 +143,7 @@ NULL

 #' @rdname ModInosine

 #' @export

 setClass("ModInosine",

-         contains = c("Modifier"),

+         contains = c("RNAModifier"),

          prototype = list(mod = "I",

                           score = "score",

                           dataType = "PileupSequenceData"))

@@ -23,8 +23,13 @@ invalidMessage <- paste0("Settings were changed after data aggregation or ",

 #' Each subclass has to implement the following functions:

 #'

 #' \itemize{

-#' \item{\code{\link{aggregateData}}: }{used for specific data aggregation}

-#' \item{\code{\link{findMod}}: }{used for specific search for modifications}

+#' \item{Slot \code{nucleotide}: } {Either "RNA" or "DNA". For conveniance the

+#' subclasses \code{RNAModifier} and \code{DNAModifier} are already available

+#' and can be inherited from.}

+#' \item{Function \code{\link{aggregateData}}: }{used for specific data 

+#' aggregation}

+#' \item{Function \code{\link{findMod}}: }{used for specific search for 

+#' modifications}

 #' }

 #'

 #' Optionally the function \code{\link[=Modifier-functions]{settings<-}} can be

@@ -106,9 +111,12 @@ invalidMessage <- paste0("Settings were changed after data aggregation or ",

 #' objects, if \code{x} is not a \code{SequenceData} object or a list of

 #' \code{SequenceData} objects.

 #'

+#' @slot nucleotide a \code{character} value, which needs to contain "RNA" or 

+#' "DNA"

 #' @slot mod a \code{character} value, which needs to contain one or more

 #' elements from the alphabet of a

-#' \code{\link[Modstrings:ModRNAString]{ModRNAString}} class.

+#' \code{\link[Modstrings:ModRNAString]{ModRNAString}} or 

+#' \code{\link[Modstrings:ModDNAString]{ModDNAString}} class.

 #' @slot score the main score identifier used for visualizations

 #' @slot dataType the class name(s) of the \code{SequenceData} class used

 #' @slot bamfiles the input bam files as \code{BamFileList}

@@ -145,8 +153,9 @@ NULL

 #'

 #' @param x,object a \code{Modifier} or \code{ModifierSet} class

 #' @param modified For \code{sequences}: \code{TRUE} or \code{FALSE}: Should

-#' the sequences be returned as a \code{ModRNAString} with the found

-#' modifications added on top of the \code{RNAString}? See

+#' the sequences be returned as a \code{ModRNAString}/\code{ModDNAString} with

+#' the found modifications added on top of the \code{RNAString}/

+#' \code{DNAString}? See 

 #' \code{\link[Modstrings:separate]{combineIntoModstrings}}.

 #' @param perTranscript \code{TRUE} or \code{FALSE}: Should the positions shown

 #' per transcript? (default: \code{perTranscript = FALSE})

@@ -156,6 +165,10 @@ NULL

 #' \itemize{

 #' \item{\code{modifierType}:} {a character vector with the appropriate class

 #' Name of a \code{\link[=Modifier-class]{Modifier}}.}

+#' \item{\code{modType}:} {a character vector with the modifications detected by

+#' the \code{Modifier} class.}

+#' \item{\code{seqtype}:} {a single character value defining if either

+#' "RNA" or "DNA" modifications are detected by the \code{Modifier} class.}

 #' \item{\code{mainScore}:} {a character vector.}

 #' \item{\code{sequenceData}:} {a \code{SequenceData} object.}

 #' \item{\code{modifications}:} {a \code{GRanges} or \code{GRangesList} object

@@ -177,7 +190,9 @@ NULL

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

 #' mi <- msi[[1]]

 #' modifierType(mi) # The class name of the Modifier object

-#' modifierType(msi) #

+#' modifierType(msi)

+#' seqtype(mi)

+#' modType(mi)

 #' mainScore(mi)

 #' sequenceData(mi)

 #' modifications(mi)

@@ -198,7 +213,8 @@ setClassUnion("list_OR_BamFileList",

 #' @export

 setClass("Modifier",

          contains = c("VIRTUAL"),

-         slots = c(mod = "character", # this have to be populated by subclass

+         slots = c(seqtype = "character", # this have to be populated by subclass,

+                   mod = "character", # this have to be populated by subclass

                    score = "character", # this have to be populated by subclass

                    dataType = "list_OR_character", # this have to be populated by subclass

                    bamfiles = "list_OR_BamFileList",

@@ -265,7 +281,18 @@ setClass("Modifier",

 }

 .valid_Modifier <- function(x){

+  if(is.null(x@seqtype)){

+    return("'seqtype' slot not populated.")

+  }

+  if(!.is_valid_nucleotide_seqtype(seqtype(x))){

+    return(paste0("'seqtype' slot must contain the character value '",

+                  seqtype(RNAString()),"' or '",seqtype(DNAString()),"'."))

+  }

   seqdata <- x@data

+  if(seqtype(x) != seqtype(seqdata)){

+    return("'seqtype' does not match seqtype() of SequenceData contained ",

+           "within Modifier object.")

+  }

   if(is.list(x@bamfiles)){

     test <- !vapply(x@bamfiles,is,logical(1),"BamFileList")

     if(any(test)){

@@ -345,7 +372,9 @@ setMethod(

         "with",length(object@data),"elements.\n")

     files <- BiocGenerics::path(object@bamfiles)

     cat("| Input files:\n",paste0("  - ",names(files),": ",files,"\n"))

-    cat("| Modification type(s): ",paste0(object@mod, collapse = " / "),"\n")

+    cat("| Nucleotide - Modification type(s): ",

+        paste0(seqtype(object), collapse = " / ")," - ",

+        paste0(modType(object), collapse = " / "),"\n")

     cat("| Modifications found:",ifelse(length(object@modifications) != 0L,

                                       paste0("yes (",

                                              length(object@modifications),

@@ -377,6 +406,7 @@ setMethod(

 setMethod(f = "bamfiles",

           signature = signature(x = "Modifier"),

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

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "conditions",

@@ -384,6 +414,7 @@ setMethod(f = "conditions",

           definition = function(object){

             object@condition

           })

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "mainScore",

@@ -430,31 +461,37 @@ setMethod(f = "modifications",

               x@modifications

             }

 )

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "modifierType",

           signature = signature(x = "Modifier"),

-          definition = function(x){class(x)[[1]]})

+          definition = function(x){class(x)[[1L]]})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "modType",

           signature = signature(x = "Modifier"),

           definition = function(x){x@mod})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "dataType",

           signature = signature(x = "Modifier"),

           definition = function(x){x@dataType})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "names",

           signature = signature(x = "Modifier"),

           definition = function(x){names(sequenceData(x))})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "ranges",

           signature = signature(x = "Modifier"),

           definition = function(x){ranges(sequenceData(x))})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "replicates",

@@ -462,11 +499,55 @@ setMethod(f = "replicates",

           definition = function(x){

             x@replicate

           })

+

+#' @rdname Modifier-functions

+#' @export

+setMethod(f = "seqinfo",

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

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

+)

+

+#' @rdname Modifier-functions

+#' @export

+setMethod(f = "seqtype",

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

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

+)

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "sequenceData",

           signature = signature(x = "Modifier"),

           definition = function(x){x@data})

+

+.get_modified_sequences <- function(x, modified){

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

+    seqData <- sequenceData(x)

+  } else if(is(x,"ModifierSet")) {

+    seqData <- sequenceData(x[[1L]])

+  } else {

+    stop("")

+  }

+  if(!modified){

+    return(sequences(seqData))

+  }

+  mod <- .get_modifications_per_transcript(x)

+  mod <- .rebase_seqnames(mod, mod$Parent)

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

+  if(seqtype(x) == seqtype(RNAString())){

+    ans <- ModRNAStringSet(sequences(seqData))

+  } else if(seqtype(x) == seqtype(DNAString())){

+    ans <- ModDNAStringSet(sequences(seqData))

+  } else {

+    stop("")

+  }

+  modSeqList <- ans[names(ans) %in% names(mod)]

+  mod <- mod[match(names(mod),names(modSeqList))]

+  ans[names(ans) %in% names(mod)] <-

+    Modstrings::combineIntoModstrings(modSeqList, mod)

+  ans

+}

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "sequences",

@@ -477,32 +558,17 @@ setMethod(f = "sequences",

                 stop("'modified' has to be a single logical value.",

                      call. = FALSE)

               }

-              if(!modified){

-                return(sequences(sequenceData(x)))

-              }

-              mod <- .get_modifications_per_transcript(x)

-              mod <- .rebase_seqnames(mod, mod$Parent)

-              mod <- split(mod,factor(mod$Parent, levels = mod$Parent))

-              ans <- ModRNAStringSet(sequences(sequenceData(x)))

-              modSeqList <- ans[names(ans) %in% names(mod)]

-              mod <- mod[match(names(mod),names(modSeqList))]

-              ans[names(ans) %in% names(mod)] <-

-                Modstrings::combineIntoModstrings(modSeqList, mod)

-              ans

+              .get_modified_sequences(x, modified)

             }

 )

-#' @rdname Modifier-functions

-#' @export

-setMethod(f = "seqinfo",

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

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

-)

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "validAggregate",

           signature = signature(x = "Modifier"),

           definition = function(x) x@aggregateValidForCurrentArguments

 )

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "validModification",

@@ -635,7 +701,7 @@ setReplaceMethod(f = "settings",

   replicate <- replicates[m]

   # create Modifier object

   new(className,

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

+      mod = .norm_mod(proto),

       bamfiles = bamfiles,

       condition = condition,

       replicate = replicate,

@@ -695,7 +761,7 @@ setReplaceMethod(f = "settings",

   proto <- new(className)

   # short cut for creating an empty object

   if(is.null(x)){

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

+    return(new2(className, mod = .norm_mod(proto)))

   }

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

   # settings

@@ -709,7 +775,8 @@ setReplaceMethod(f = "settings",

   # get SequenceData

   data <- .load_SequenceData(dataType(proto), bamfiles = bamfiles,

                              annotation = annotation, sequences = sequences,

-                             seqinfo = seqinfo, args = settings(proto))

+                             seqinfo = seqinfo,

+                             args = list(settings(proto),seqtype(proto)))

   .new_ModFromSequenceData(className, data, ...)

 }

@@ -723,8 +790,15 @@ setReplaceMethod(f = "settings",

   ans <- aggregate(ans)

   # search for modifications

   if(settings(ans,"find.mod")){

-    f <- which(Modstrings::shortName(Modstrings::ModRNAString()) %in% ans@mod)

-    modName <- Modstrings::fullName(Modstrings::ModRNAString())[f]

+    if(seqtype(ans) == seqtype(RNAString())){

+      f <- which(Modstrings::shortName(Modstrings::ModRNAString()) %in% modType(ans))

+      modName <- Modstrings::fullName(Modstrings::ModRNAString())[f]

+    } else if(seqtype(ans) == seqtype(DNAString())){

+      f <- which(Modstrings::shortName(Modstrings::ModDNAString()) %in% modType(ans))

+      modName <- Modstrings::fullName(Modstrings::ModDNAString())[f]

+    } else {

+      stop("")

+    }

     message("Starting to search for '", paste(tools::toTitleCase(modName),

                                               collapse = "', '"),

             "' ... ", appendLF = FALSE)

@@ -1013,3 +1087,17 @@ setMethod(f = "findMod",

                    '",class(x),"'.",call. = FALSE)

             }

 )

+

+# RNAModifier and DNAModifier --------------------------------------------------

+

+#' @rdname Modifier-class

+#' @export

+setClass("RNAModifier",

+         contains = c("VIRTUAL","Modifier"),

+         prototype = list(seqtype = seqtype(RNAString())))

+

+#' @rdname Modifier-class

+#' @export

+setClass("DNAModifier",

+         contains = c("VIRTUAL","Modifier"),

+         prototype = list(seqtype = seqtype(DNAString())))

@@ -37,9 +37,10 @@ NULL

 #' \item{\code{type}:} {the modification type used for subsetting. By default 

 #' this is derived from the \code{modType(x)}, but it can be overwritten using 

 #' \code{type}. It must be a valid shortName for a modification according to

-#' \code{shortName(ModRNAString())} and of course be present in metadata column 

-#' \code{mod} of \code{coord}. To disable subsetting based on type, set 

-#' \code{type = NA}.}

+#' \code{shortName(ModRNAString())} or \code{shortName(ModDNAString())} 

+#' (depending on the type of Modifier class) and of course be present in 

+#' metadata column \code{mod} of \code{coord}. To disable subsetting based on 

+#' type, set \code{type = NA}.}

 #' \item{\code{flanking}:} {a single integer value to select how many flanking

 #' position should be included in the subset (default: \code{flanking = 0L}).}

 #' \item{\code{merge}:} {\code{TRUE} or \code{FALSE}: Should the 

@@ -17,7 +17,8 @@ setMethod(f = "constructModRanges",

             if(!.is_valid_modType(modType)){

               stop("Modification '",modType,"' not found in the short name ",

                    "alphabet from the Modstrings package. ",

-                   "'shortName(ModRNAString())'",call. = FALSE)

+                   "'shortName(ModRNAString())' or 'shortName(ModDNAString())'",

+                   call. = FALSE)

             }

             positions <- as.integer(rownames(data))

             scores <- do.call(scoreFun,

@@ -338,7 +338,8 @@ setMethod(

   signature = signature(object = "ModifierSet"),

   definition = function(object) {

     callNextMethod()

-    cat("| Modification type(s): ",paste0(object[[1]]@mod, collapse = " / "))

+    cat("| Modification type(s): ",

+        paste0(modType(object[[1]]),collapse = " / "))

     mf <- lapply(seq_along(object),

                  function(i){

                    o <- object[[i]]

@@ -399,6 +400,7 @@ setMethod(f = "bamfiles",

             S4Vectors::SimpleList(lapply(x, bamfiles))

           }

 )

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "conditions", 

@@ -407,12 +409,13 @@ setMethod(f = "conditions",

             ans <- S4Vectors::SimpleList(lapply(object,conditions))

             ans

           })

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "mainScore", 

           signature = signature(x = "ModifierSet"),

-          definition = function(x) mainScore(new(elementType(x)))

-)

+          definition = function(x) mainScore(new(elementType(x))))

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "modifications", 

@@ -421,32 +424,33 @@ setMethod(f = "modifications",

             GenomicRanges::GRangesList(lapply(x,modifications,perTranscript))

           }

 )

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "modifierType", 

           signature = signature(x = "ModifierSet"),

-          definition = function(x) modifierType(new(elementType(x)))

-)

+          definition = function(x) modifierType(new(elementType(x))))

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "modType", 

           signature = signature(x = "ModifierSet"),

-          definition = function(x) modType(new(elementType(x)))

-)

+          definition = function(x) modType(new(elementType(x))))

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "dataType", 

           signature = signature(x = "ModifierSet"),

-          definition = function(x){dataType(x[[1]])}

-)

+          definition = function(x){dataType(x[[1L]])})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "ranges", 

           signature = signature(x = "ModifierSet"),

           definition = function(x){

             ranges(x[[1]])

-          }

-)

+          })

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "replicates", 

@@ -455,6 +459,7 @@ setMethod(f = "replicates",

             ans <- S4Vectors::SimpleList(lapply(x,replicates))

             ans

           })

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "seqinfo", 

@@ -463,6 +468,13 @@ setMethod(f = "seqinfo",

             S4Vectors::SimpleList(lapply(x, seqinfo))

           }

 )

+

+#' @rdname Modifier-functions

+#' @export

+setMethod(f = "seqtype", 

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

+          definition = function(x){seqtype(x[[1L]])})

+

 #' @rdname Modifier-functions

 #' @export

 setMethod(f = "sequences", 

@@ -473,18 +485,7 @@ setMethod(f = "sequences",

                 stop("'modified' has to be a single logical value.",

                      call. = FALSE)

               }

-              if(!modified){

-                return(sequences(sequenceData(x[[1]])))

-              }

-              mod <- .get_modifications_per_transcript(x)

-              mod <- .rebase_seqnames(mod, mod$Parent)

-              mod <- split(mod,factor(mod$Parent, levels = mod$Parent))

-              ans <- ModRNAStringSet(sequences(sequenceData(x[[1]])))

-              modSeqList <- ans[names(ans) %in% names(mod)]

-              mod <- mod[match(names(mod),names(modSeqList))]

-              ans[names(ans) %in% names(mod)] <- 

-                Modstrings::combineIntoModstrings(modSeqList, mod)

-              ans

+              .get_modified_sequences(x, modified)

             }

 )

@@ -70,8 +70,9 @@ NULL

 #' @import BiocGenerics

 #' @import XVector

 #' @importFrom Biostrings DNAString RNAString DNAStringSet RNAStringSet getSeq

-#' @importFrom Modstrings ModRNAString ModRNAStringSet combineIntoModstrings

-#' shortName fullName

+#' seqtype seqtype<-

+#' @importFrom Modstrings ModRNAString ModRNAStringSet ModDNAString 

+#' ModDNAStringSet combineIntoModstrings shortName fullName

 #' @importClassesFrom IRanges IntegerList CharacterList LogicalList IRanges

 #' SplitDataFrameList PartitioningByEnd PartitioningByWidth

 #' @importFrom IRanges IntegerList CharacterList LogicalList IRanges

@@ -89,7 +89,8 @@ NULL

 #' description of this argument.

 #' 

 #' @slot sequencesType a \code{character} value for the class name of 

-#' \code{sequences}. Either \code{RNAStringSet} or \code{ModRNAStringSet}.

+#' \code{sequences}. Either \code{RNAStringSet}, \code{ModRNAStringSet}, 

+#' \code{DNAStringSet} or \code{ModDNAStringSet}.

 #' @slot minQuality a \code{integer} value describing a threshold of the minimum

 #' quality of reads to be used.

 #' 

@@ -98,12 +99,10 @@ NULL

 setClass("SequenceData",

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

-         slots = c(sequencesType = "character",

-                   minQuality = "integer",

+         slots = c(minQuality = "integer",

                    unlistData = "SequenceDataFrame",

                    unlistType = "character",

-                   dataDescription = "character"),

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

+                   dataDescription = "character"))

 setMethod(

   f = "initialize",

@@ -112,9 +111,6 @@ setMethod(

     if(!assertive::is_a_non_empty_string(.Object@dataDescription)){

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

     }

-    if(!(.Object@sequencesType %in% c("RNAStringSet","ModRNAStringSet"))){

-      stop("'sequencesType' must be either 'RNAStringSet' or 'ModRNAStringSet'")

-    }

     callNextMethod(.Object, ...)

   }

 )

@@ -469,9 +465,6 @@ setMethod("unlist", "SequenceData",

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

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

   }

-  if(!(proto@sequencesType %in% c("RNAStringSet","ModRNAStringSet"))){

-    stop("'sequencesType' must be either 'RNAStringSet' or 'ModRNAStringSet'")

-  }

   if(is.null(minQuality)){

     stop("Minimum quality is not set for '", className ,"'.",

          call. = FALSE)

@@ -508,7 +501,6 @@ setMethod("unlist", "SequenceData",

   rownames(data) <- IRanges::CharacterList(positions)

   data <- .order_read_data_by_strand(data, ranges)

   # order sequences

-  sequences <- as(sequences, proto@sequencesType)

   sequences <- sequences[match(names(ranges), names(sequences))]

   # basic checks

   names(data) <- names(ranges)

@@ -540,16 +532,20 @@ setMethod("unlist", "SequenceData",

 .SequenceData_settings <- data.frame(

   variable = c("max_depth",

                "minLength",

-               "maxLength"),

+               "maxLength",

+               "seqtype"),

   testFUN = c(".not_integer_bigger_than_10",

               ".not_integer_bigger_equal_than_zero_nor_na",

-              ".not_integer_bigger_equal_than_one_nor_na"),

+              ".not_integer_bigger_equal_than_one_nor_na",

+              ".is_valid_nucleotide_seqtype"),

   errorValue = c(TRUE,

                  TRUE,

-                 TRUE),

+                 TRUE,

+                 FALSE),

   errorMessage = c("'max_depth' must be integer with a value higher than 10L.",

                    "'minLength' must be integer with a value higher than 0L or NA.",

-                   "'maxLength' must be integer with a value higher than 1L or NA."),

+                   "'maxLength' must be integer with a value higher than 1L or NA.",

+                   paste0("'seqtype' must be either '",seqtype(RNAString()) ,"' or '",seqtype(DNAString()) ,"'.")),

   stringsAsFactors = FALSE)

 .get_SequenceData_args <- function(input){

@@ -557,8 +553,9 @@ setMethod("unlist", "SequenceData",

   max_depth <- 10000L # the default is 250, which is to small

   minLength <- NA_integer_

   maxLength <- NA_integer_

+  seqtype <- seqtype(RNAString()) 

   args <- .norm_settings(input, .SequenceData_settings, max_depth, minLength,

-                         maxLength)

+                         maxLength, seqtype)

   if(!is.na(args[["minLength"]]) && !is.na(args[["maxLength"]])){

     if(args[["minLength"]] > args[["maxLength"]]){

       stop("'minLength' must be smaller or equal to 'maxLength'.",

@@ -596,7 +593,7 @@ setMethod("unlist", "SequenceData",

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

     }

   }

-  sequences <- .load_transcript_sequences(sequences, grl)

+  sequences <- .load_sequences(sequences, grl, args)

   # create the class

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

 }

@@ -643,11 +640,12 @@ setMethod("unlist", "SequenceData",

 #' @importFrom Biostrings xscat

 # load the transcript sequence per transcript aka. one sequence per GRangesList

 # element

-.load_transcript_sequences <- function(sequences, grl){

+.load_sequences <- function(sequences, grl, args){

   seq <- Biostrings::getSeq(sequences, unlist(grl))

   seq <- relist(unlist(seq),IRanges::PartitioningByWidth(sum(width(grl))))

   names(seq) <- names(grl)

-  as(seq,"RNAStringSet")

+  seqtype(seq) <- args[["seqtype"]]

+  seq

 }

 # remove any elements, which are not in the seqinfo

@@ -788,11 +786,13 @@ setMethod("getData",

 setMethod(f = "bamfiles", 

           signature = signature(x = "SequenceData"),

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

+

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "conditions", 

           signature = signature(object = "SequenceData"),

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

+

 #' @rdname SequenceData-functions

 #' @export

 setMethod(

@@ -810,21 +810,41 @@ setMethod(

       names(partitioning_relist) <- names(x)

       relist(unlisted_ranges, partitioning_relist)

     })

+

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "replicates", 

           signature = signature(x = "SequenceData"),

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

+

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "seqinfo", 

           signature = signature(x = "SequenceData"),

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

+

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "sequences", 

           signature = signature(x = "SequenceData"),

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

+

+#' @rdname SequenceData-functions

+#' @export

+setMethod(f = "seqtype", 

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

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

+

+#' @rdname SequenceData-functions

+#' @export

+setReplaceMethod(f = "seqtype", 

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

+                 definition = function(x, value){

+                   unlisted_x <- unlist(x)

+                   seqtype(unlisted_x) <- value

+                   relist(unlisted_x,x)

+                 })

+

 #' @rdname SequenceData-functions

 #' @export

 setMethod(f = "dataType",

@@ -41,8 +41,10 @@ NULL

 .norm_subset_args <- function(input,x){

   name <- NA_character_

   if(is(x,"Modifier") || is(x,"ModifierSet")){

+    seqtype <- seqtype(x)

     type <- modType(x)

   } else {

+    seqtype <- NA_character_

     type <- NA_character_

   }

   merge <- TRUE

@@ -53,8 +55,9 @@ NULL

   args <- .norm_settings(input, .subset_settings, name, type, merge, flanking,

                          perTranscript, sequenceData, rawData)

   if(all(!is.na(args[["type"]]))){

-    if(any(!.is_valid_modType(args[["type"]]))){

-      stop("'type' must be one or more elements of shortName(ModRNAString()).",

+    if(any(!.is_valid_modType(args[["type"]], seqtype))){

+      stop("'type' must be one or more elements of 'shortName(ModRNAString())'",

+           " or 'shortName(ModDNAString())'.",

            call. = FALSE)

     }

   }

@@ -216,22 +216,22 @@ NULL

                        args[["sequence.track.pars"]]))

     track

   }

-  if(!is(seq,"DNAStringSet") && 

-     !is(seq,"RNAStringSet") && 

-     !is(seq,"ModRNAStringSet")){

+  if(!is(seq,"DNAStringSet") &&  !is(seq,"RNAStringSet") && 

+     !is(seq,"ModRNAStringSet") && !is(seq,"ModDNAStringSet")){

     stop("Invalid sequence type '",class(seq),"'. sequences(x) must be a ",

-         "RNA/ModRNA/DNAStringSet.",

+         "RNA/ModRNA/DNA/ModDNA*StringSet.",

          call. = FALSE)

   }

-  if(is(seq,"DNAStringSet")){

-    seq <- as(seq,"RNAStringSet")

-  }

   # reconstruct the chromosomal sequences for plotting

   seq <- .stitch_chromosome(seq, ranges, chromosome)

   if(is(seq,"RNAStringSet")){

     st <- FUN("RNASequenceTrack","RNAStringSet", seq, args)

   } else if(is(seq,"ModRNAStringSet")){

     st <- FUN("ModRNASequenceTrack","ModRNAStringSet", seq, args)

+  } else if(is(seq,"DNAStringSet")){

+    st <- FUN("SequenceTrack","DNAStringSet", seq, args)

+  } else if(is(seq,"ModDNAStringSet")){

+    st <- FUN("ModDNASequenceTrack","ModDNAStringSet", seq, args)

   } else {

     stop("")

   }

@@ -16,10 +16,12 @@ NULL

 #' \code{SequenceDataList} or a \code{SequenceDataFrame} object.

 #' @param bamfiles a \code{BamFileList}.

 #' @param grl a \code{GRangesList} from \code{exonsBy(..., by = "tx")}

-#' @param sequences a \code{XStringSet} of type \code{RNAStringSet} or 

-#' \code{ModRNAStringSet}

+#' @param sequences a \code{XStringSet} of type \code{RNAStringSet}, 

+#' \code{ModRNAStringSet}, \code{DNAStringSet} or 

+#' \code{ModDNAStringSet}

 #' @param param a \code{\link[Rsamtools:ScanBamParam-class]{ScanBamParam}} 

 #' object

+#' @param value a new \code{seqtype}, either "RNA" or "DNA"

 #' @param args a list of addition arguments

 #' 

 #' @return 

@@ -151,9 +153,23 @@ setMethod("show", "SequenceDataFrame",

 #' @rdname SequenceData-functions

 #' @export

 setMethod(

-  f = "sequences", 

+  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@sequence})

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