@@ -278,6 +278,9 @@ gmql_take <- function(input_data, rows) {

         #levels(x$start)[x$start] = start_numeric

         g <- GenomicRanges::makeGRangesFromDataFrame(

             x,

+            seqnames.field = c("seqnames", "seqname",

+                               "chromosome", "chrom",

+                               "chr", "chromosome_name"),

             keep.extra.columns = TRUE,

             start.field = "start",

             end.field = "end")

@@ -32,71 +32,72 @@

 #' @export

 #'

 execute <- function() {

-  WrappeR <- J("it/polimi/genomics/r/Wrapper")

-  remote_proc <- WrappeR$is_remote_processing()

-  datasets <- .jevalArray(WrappeR$get_dataset_list(), simplify = TRUE)

-  exists_credential <- exists("GMQL_credentials", envir = .GlobalEnv)

-  

-  if(!remote_proc && exists_credential)

-    .download_or_upload(datasets)

-  

-  response <- WrappeR$execute()

-  error <- strtoi(response[1])

-  val <- response[2]

-  if(error)

-    stop(val)

-  else {

-    if(remote_proc) {

-      isGTF <- FALSE

-      outformat <- WrappeR$outputMaterialize()

-      if(identical(outformat, "gtf"))

-        isGTF <- TRUE

-      

-      credential <- get("GMQL_credentials", envir = .GlobalEnv)

-      url <- credential$remote_url

-      

-      if(is.null(url))

-        stop("url from GMQL_credentials is missing")

-      

-      .download_or_upload(datasets)

-      res <- serialize_query(url,isGTF,val)

+    WrappeR <- J("it/polimi/genomics/r/Wrapper")

+    remote_proc <- WrappeR$is_remote_processing()

+    datasets <- .jevalArray(WrappeR$get_dataset_list(), simplify = TRUE)

+    exists_credential <- exists("GMQL_credentials", envir = .GlobalEnv)

+    

+    if(!remote_proc && exists_credential)

+        .download_or_upload(datasets)

+    

+    response <- WrappeR$execute()

+    error <- strtoi(response[1])

+    val <- response[2]

+    if(error)

+        stop(val)

+    else {

+        if(remote_proc) {

+            isGTF <- FALSE

+            outformat <- WrappeR$outputMaterialize()

+            if(identical(outformat, "gtf"))

+                isGTF <- TRUE

+            

+            credential <- get("GMQL_credentials", envir = .GlobalEnv)

+            url <- credential$remote_url

+            

+            if(is.null(url))

+                stop("url from GMQL_credentials is missing")

+            

+            .download_or_upload(datasets)

+            res <- serialize_query(url,isGTF,val)

+        }

     }

-  }

 }

 .download_or_upload <- function(datasets) {

-  WrappeR <- J("it/polimi/genomics/r/Wrapper")

-  data_list <- apply(datasets, 1, as.list)

-  

-  credential <- get("GMQL_credentials", envir = .GlobalEnv)

-  url <- credential$remote_url

-  

-  if(is.null(url))

-    stop("url from GMQL_credentials is missing")

-  

-  remote <- WrappeR$is_remote_processing()

-  if(remote) {

-    lapply(data_list,function(x) {

-      if(!is.null(x[[1]]) && !is.na(x[[1]]))

-        upload_dataset(url,x[[2]],x[[1]],x[[3]]) 

-    })

-  } else {

-    lapply(data_list,function(x) {

-      if(!is.null(x[[2]]) && !is.na(x[[2]])) {

-        path <- x[[1]]

-        # create downloads folder where putting all the downloading dataset

-        if(!dir.exists(path))

-          dir.create(path)

-        

-        download_dataset(url,x[[2]], path) 

-      }

-    })

-  }

+    WrappeR <- J("it/polimi/genomics/r/Wrapper")

+    data_list <- apply(datasets, 1, as.list)

+    

+    credential <- get("GMQL_credentials", envir = .GlobalEnv)

+    url <- credential$remote_url

+    

+    if(is.null(url))

+        stop("url from GMQL_credentials is missing")

+    

+    remote <- WrappeR$is_remote_processing()

+    if(remote) {

+        lapply(data_list,function(x) {

+            if(!is.null(x[[1]]) && !is.na(x[[1]]))

+                upload_dataset(url,x[[2]],x[[1]],x[[3]]) 

+        })

+    } else {

+        lapply(data_list,function(x) {

+            if(!is.null(x[[2]]) && !is.na(x[[2]])) {

+                path <- x[[1]]

+                # create downloads folder where putting all the downloading 

+                # dataset

+                if(!dir.exists(path))

+                    dir.create(path)

+                

+                download_dataset(url,x[[2]], path) 

+            }

+        })

+    }

 }

 collect.GMQLDataset <- function(x,  name = "ds1", dir_out = getwd()) {

-  ptr_data <- value(x)

-  gmql_materialize(ptr_data, name, dir_out)

+    ptr_data <- value(x)

+    gmql_materialize(ptr_data, name, dir_out)

 }

@@ -151,28 +152,27 @@ collect.GMQLDataset <- function(x,  name = "ds1", dir_out = getwd()) {

 setMethod("collect", "GMQLDataset",collect.GMQLDataset)

 gmql_materialize <- function(input_data, name, dir_out) {

-  WrappeR <- J("it/polimi/genomics/r/Wrapper")

-  remote_proc <- WrappeR$is_remote_processing()

-  

-  if(grepl("\\.",name))

-    stop("dataset name cannot contains dot")

-  

-  if(!remote_proc) {

-    dir_out <- sub("/*[/]$","",dir_out)

-    res_dir_out <- file.path(dir_out, name)

-    if(!dir.exists(res_dir_out))

-      dir.create(res_dir_out)

-  }

-  else

-    res_dir_out <- name

-  

-  response <- WrappeR$materialize(input_data, res_dir_out)

-  error <- strtoi(response[1])

-  val <- response[2]

-  if(error)

-    stop(val)

-  else

-    invisible(NULL)

+    WrappeR <- J("it/polimi/genomics/r/Wrapper")

+    remote_proc <- WrappeR$is_remote_processing()

+    

+    if(grepl("\\.",name))

+        stop("dataset name cannot contains dot")

+    

+    if(!remote_proc) {

+        dir_out <- sub("/*[/]$","",dir_out)

+        res_dir_out <- file.path(dir_out, name)

+        if(!dir.exists(res_dir_out))

+            dir.create(res_dir_out)

+    } else

+        res_dir_out <- name

+    

+    response <- WrappeR$materialize(input_data, res_dir_out)

+    error <- strtoi(response[1])

+    val <- response[2]

+    if(error)

+        stop(val)

+    else

+        invisible(NULL)

 }

@@ -231,72 +231,73 @@ gmql_materialize <- function(input_data, name, dir_out) {

 #' @rdname take

 #' @aliases take-method

 #' @export

-setMethod("take", "GMQLDataset",

-          function(.data, rows = 0L)

-          {

-            ptr_data <- value(.data)

-            gmql_take(ptr_data, rows)

-          })

+setMethod(

+    "take", 

+    "GMQLDataset",

+    function(.data, rows = 0L) {

+        ptr_data <- value(.data)

+        gmql_take(ptr_data, rows)

+})

 gmql_take <- function(input_data, rows) {

-  rows <- as.integer(rows[1])

-  if(rows<0)

-    stop("rows cannot be negative")

-  

-  WrappeR <- J("it/polimi/genomics/r/Wrapper")

-  response <- WrappeR$take(input_data, rows)

-  error <- strtoi(response[1])

-  data <- response[2]

-  if(error)

-    stop(data)

-  

-  reg <- .jevalArray(WrappeR$get_reg(),simplify = TRUE)

-  if(is.null(reg))

-    stop("no regions defined")

-  meta <- .jevalArray(WrappeR$get_meta(),simplify = TRUE)

-  if(is.null(meta))

-    stop("no metadata defined")

-  schema <- .jevalArray(WrappeR$get_schema(),simplify = TRUE)

-  if(is.null(schema))

-    stop("no schema defined")

-  

-  reg_data_frame <- as.data.frame(reg)

-  if (!length(reg_data_frame)){

-    return(GRangesList())

-  }

-  list <- split(reg_data_frame, reg_data_frame[1])

-  seq_name <- c("seqname","start","end","strand",schema)

-  

-  sampleList <- lapply(list, function(x){

-    x <- x[-1]

-    names(x) <- seq_name

-    #    start_numeric = as.numeric(levels(x$start))[x$start]

-    start_numeric = as.numeric(x$start)

-    start_numeric = start_numeric + 1

-    x$start =  start_numeric

-    #levels(x$start)[x$start] = start_numeric

-    g <- GenomicRanges::makeGRangesFromDataFrame(

-      x,

-      keep.extra.columns = TRUE,

-      start.field = "start",

-      end.field = "end")

-  })

-  

-  gRange_list <- GRangesList(sampleList)

-  len = length(gRange_list)

-  names(gRange_list) <- paste0("S_",seq_len(len))

-  meta_list <- .metadata_from_frame_to_list(meta)

-  names(meta_list) <- paste0("S_",seq_len(len))

-  S4Vectors::metadata(gRange_list) <- meta_list

-  return(gRange_list)

+    rows <- as.integer(rows[1])

+    if(rows<0)

+        stop("rows cannot be negative")

+    

+    WrappeR <- J("it/polimi/genomics/r/Wrapper")

+    response <- WrappeR$take(input_data, rows)

+    error <- strtoi(response[1])

+    data <- response[2]

+    if(error)

+        stop(data)

+    

+    reg <- .jevalArray(WrappeR$get_reg(),simplify = TRUE)

+    if(is.null(reg))

+        stop("no regions defined")

+    meta <- .jevalArray(WrappeR$get_meta(),simplify = TRUE)

+    if(is.null(meta))

+        stop("no metadata defined")

+    schema <- .jevalArray(WrappeR$get_schema(),simplify = TRUE)

+    if(is.null(schema))

+        stop("no schema defined")

+    

+    reg_data_frame <- as.data.frame(reg)

+    if (!length(reg_data_frame)){

+        return(GRangesList())

+    }

+    list <- split(reg_data_frame, reg_data_frame[1])

+    seq_name <- c("seqname","start","end","strand",schema)

+    

+    sampleList <- lapply(list, function(x){

+        x <- x[-1]

+        names(x) <- seq_name

+        #    start_numeric = as.numeric(levels(x$start))[x$start]

+        start_numeric = as.numeric(x$start)

+        start_numeric = start_numeric + 1

+        x$start =  start_numeric

+        #levels(x$start)[x$start] = start_numeric

+        g <- GenomicRanges::makeGRangesFromDataFrame(

+            x,

+            keep.extra.columns = TRUE,

+            start.field = "start",

+            end.field = "end")

+    })

+    

+    gRange_list <- GRangesList(sampleList)

+    len = length(gRange_list)

+    names(gRange_list) <- paste0("S_",seq_len(len))

+    meta_list <- .metadata_from_frame_to_list(meta)

+    names(meta_list) <- paste0("S_",seq_len(len))

+    S4Vectors::metadata(gRange_list) <- meta_list

+    return(gRange_list)

 }

 .metadata_from_frame_to_list <- function(metadata_frame) {

-  meta_frame <- as.data.frame(metadata_frame)

-  list <- split(meta_frame, meta_frame[1])

-  name_value_list <- lapply(list, function(x){x <- x[-1]})

-  meta_list <- lapply(name_value_list, function(x){

-    stats::setNames(as.list(as.character(x[[2]])), x[[1]])

-  })

+    meta_frame <- as.data.frame(metadata_frame)

+    list <- split(meta_frame, meta_frame[1])

+    name_value_list <- lapply(list, function(x){x <- x[-1]})

+    meta_list <- lapply(name_value_list, function(x){

+        stats::setNames(as.list(as.character(x[[2]])), x[[1]])

+    })

 }

@@ -35,8 +35,9 @@ execute <- function() {

   WrappeR <- J("it/polimi/genomics/r/Wrapper")

   remote_proc <- WrappeR$is_remote_processing()

   datasets <- .jevalArray(WrappeR$get_dataset_list(), simplify = TRUE)

+  exists_credential <- exists("GMQL_credentials", envir = .GlobalEnv)

-  if(!remote_proc)

+  if(!remote_proc && exists_credential)

     .download_or_upload(datasets)

   response <- WrappeR$execute()

@@ -75,13 +75,21 @@ execute <- function() {

   remote <- WrappeR$is_remote_processing()

   if(remote) {

-    lapply(data_list,function(x){

+    lapply(data_list,function(x) {

       if(!is.null(x[[1]]) && !is.na(x[[1]]))

-        upload_dataset(url,x[[2]],x[[1]],x[[3]])})

+        upload_dataset(url,x[[2]],x[[1]],x[[3]]) 

+    })

   } else {

-    lapply(data_list,function(x){

-      if(!is.null(x[[2]]) && !is.na(x[[2]]))

-        download_dataset(url,x[[2]],x[[1]])})

+    lapply(data_list,function(x) {

+      if(!is.null(x[[2]]) && !is.na(x[[2]])) {

+        path <- x[[1]]

+        # create downloads folder where putting all the downloading dataset

+        if(!dir.exists(path))

+          dir.create(path)

+        

+        download_dataset(url,x[[2]], path) 

+      }

+    })

   }

 }

@@ -150,7 +158,7 @@ gmql_materialize <- function(input_data, name, dir_out) {

   if(!remote_proc) {

     dir_out <- sub("/*[/]$","",dir_out)

-    res_dir_out <- file.path(dir_out,name)

+    res_dir_out <- file.path(dir_out, name)

     if(!dir.exists(res_dir_out))

       dir.create(res_dir_out)

   }

@@ -51,7 +51,12 @@ execute <- function() {

       if(identical(outformat, "gtf"))

         isGTF <- TRUE

-      url <- WrappeR$get_url()

+      credential <- get("GMQL_credentials", envir = .GlobalEnv)

+      url <- credential$remote_url

+      

+      if(is.null(url))

+        stop("url from GMQL_credentials is missing")

+      

       .download_or_upload(datasets)

       res <- serialize_query(url,isGTF,val)

     }

@@ -61,7 +66,13 @@ execute <- function() {

 .download_or_upload <- function(datasets) {

   WrappeR <- J("it/polimi/genomics/r/Wrapper")

   data_list <- apply(datasets, 1, as.list)

-  url <- WrappeR$get_url()

+  

+  credential <- get("GMQL_credentials", envir = .GlobalEnv)

+  url <- credential$remote_url

+  

+  if(is.null(url))

+    stop("url from GMQL_credentials is missing")

+  

   remote <- WrappeR$is_remote_processing()

   if(remote) {

     lapply(data_list,function(x){

@@ -74,9 +85,9 @@ execute <- function() {

   }

 }

-collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1") {

+collect.GMQLDataset <- function(x,  name = "ds1", dir_out = getwd()) {

   ptr_data <- value(x)

-  gmql_materialize(ptr_data, dir_out, name)

+  gmql_materialize(ptr_data, name, dir_out)

 }

@@ -66,7 +66,7 @@ execute <- function() {

   if(remote) {

     lapply(data_list,function(x){

       if(!is.null(x[[1]]) && !is.na(x[[1]]))

-        upload_dataset(url,x[[2]],x[[1]],x[[3]],FALSE)})

+        upload_dataset(url,x[[2]],x[[1]],x[[3]])})

   } else {

     lapply(data_list,function(x){

       if(!is.null(x[[2]]) && !is.na(x[[2]]))

@@ -31,53 +31,52 @@

 #' }

 #' @export

 #'

-execute <- function()

-{

-    WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    remote_proc <- WrappeR$is_remote_processing()

-    datasets <- .jevalArray(WrappeR$get_dataset_list(),simplify = TRUE)

-    

-    if(!remote_proc)

-        .download_or_upload(datasets)

-    

-    response <- WrappeR$execute()

-    error <- strtoi(response[1])

-    val <- response[2]

-    if(error)

-        stop(val)

-    else {

-        if(remote_proc) {

-            isGTF <- FALSE

-            outformat <- WrappeR$outputMaterialize()

-            if(identical(outformat, "gtf"))

-                isGTF <- TRUE

-            

-            url <- WrappeR$get_url()

-            .download_or_upload(datasets)

-            res <- serialize_query(url,isGTF,val)

-        }

+execute <- function() {

+  WrappeR <- J("it/polimi/genomics/r/Wrapper")

+  remote_proc <- WrappeR$is_remote_processing()

+  datasets <- .jevalArray(WrappeR$get_dataset_list(), simplify = TRUE)

+  

+  if(!remote_proc)

+    .download_or_upload(datasets)

+  

+  response <- WrappeR$execute()

+  error <- strtoi(response[1])

+  val <- response[2]

+  if(error)

+    stop(val)

+  else {

+    if(remote_proc) {

+      isGTF <- FALSE

+      outformat <- WrappeR$outputMaterialize()

+      if(identical(outformat, "gtf"))

+        isGTF <- TRUE

+      

+      url <- WrappeR$get_url()

+      .download_or_upload(datasets)

+      res <- serialize_query(url,isGTF,val)

     }

+  }

 }

 .download_or_upload <- function(datasets) {

-    WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    data_list <- apply(datasets, 1, as.list)

-    url <- WrappeR$get_url()

-    remote <- WrappeR$is_remote_processing()

-    if(remote) {

-        lapply(data_list,function(x){

-            if(!is.null(x[[1]]) && !is.na(x[[1]]))

-                upload_dataset(url,x[[2]],x[[1]],x[[3]],FALSE)})

-    } else {

-        lapply(data_list,function(x){

-            if(!is.null(x[[2]]) && !is.na(x[[2]]))

-                download_dataset(url,x[[2]],x[[1]])})

-    }

+  WrappeR <- J("it/polimi/genomics/r/Wrapper")

+  data_list <- apply(datasets, 1, as.list)

+  url <- WrappeR$get_url()

+  remote <- WrappeR$is_remote_processing()

+  if(remote) {

+    lapply(data_list,function(x){

+      if(!is.null(x[[1]]) && !is.na(x[[1]]))

+        upload_dataset(url,x[[2]],x[[1]],x[[3]],FALSE)})

+  } else {

+    lapply(data_list,function(x){

+      if(!is.null(x[[2]]) && !is.na(x[[2]]))

+        download_dataset(url,x[[2]],x[[1]])})

+  }

 }

 collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1") {

-    ptr_data <- value(x)

-    gmql_materialize(ptr_data, dir_out, name)

+  ptr_data <- value(x)

+  gmql_materialize(ptr_data, dir_out, name)

 }

@@ -95,9 +94,9 @@ collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1") {

 #' @importFrom dplyr collect

 #' 

 #' @param x GMQLDataset class object

+#' @param name name of the result dataset. By default it is the string "ds1"

 #' @param dir_out destination folder path. By default it is the current 

 #' working directory of the R process

-#' @param name name of the result dataset. By default it is the string "ds1"

 #' 

 #' @details 

 #' 

@@ -131,28 +130,29 @@ collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1") {

 #' @export

 setMethod("collect", "GMQLDataset",collect.GMQLDataset)

-gmql_materialize <- function(input_data, dir_out, name) {

-    WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    remote_proc <- WrappeR$is_remote_processing()

-    if(!remote_proc) {

-        dir_out <- sub("/*[/]$","",dir_out)

-        res_dir_out <- file.path(dir_out,name)

-        if(!dir.exists(res_dir_out))

-            dir.create(res_dir_out)

-    }

-    else

-        res_dir_out <- dir_out

-    

-    if(grepl("\\.",name))

-        stop("dataset name cannot contains dot")

-    

-    response <- WrappeR$materialize(input_data, res_dir_out)

-    error <- strtoi(response[1])

-    val <- response[2]

-    if(error)

-        stop(val)

-    else

-        invisible(NULL)

+gmql_materialize <- function(input_data, name, dir_out) {

+  WrappeR <- J("it/polimi/genomics/r/Wrapper")

+  remote_proc <- WrappeR$is_remote_processing()

+  

+  if(grepl("\\.",name))

+    stop("dataset name cannot contains dot")

+  

+  if(!remote_proc) {

+    dir_out <- sub("/*[/]$","",dir_out)

+    res_dir_out <- file.path(dir_out,name)

+    if(!dir.exists(res_dir_out))

+      dir.create(res_dir_out)

+  }

+  else

+    res_dir_out <- name

+  

+  response <- WrappeR$materialize(input_data, res_dir_out)

+  error <- strtoi(response[1])

+  val <- response[2]

+  if(error)

+    stop(val)

+  else

+    invisible(NULL)

 }

@@ -212,72 +212,71 @@ gmql_materialize <- function(input_data, dir_out, name) {

 #' @aliases take-method

 #' @export

 setMethod("take", "GMQLDataset",

-            function(.data, rows = 0L)

-            {

-                ptr_data <- value(.data)

-                gmql_take(ptr_data, rows)

-            })

+          function(.data, rows = 0L)

+          {

+            ptr_data <- value(.data)

+            gmql_take(ptr_data, rows)

+          })

 gmql_take <- function(input_data, rows) {

-    rows <- as.integer(rows[1])

-    if(rows<0)

-        stop("rows cannot be negative")

-    

-    WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    response <- WrappeR$take(input_data, rows)

-    error <- strtoi(response[1])

-    data <- response[2]

-    if(error)

-        stop(data)

-    

-    reg <- .jevalArray(WrappeR$get_reg(),simplify = TRUE)

-    if(is.null(reg))

-        stop("no regions defined")

-    meta <- .jevalArray(WrappeR$get_meta(),simplify = TRUE)

-    if(is.null(meta))

-        stop("no metadata defined")

-    schema <- .jevalArray(WrappeR$get_schema(),simplify = TRUE)

-    if(is.null(schema))

-        stop("no schema defined")

-    

-    reg_data_frame <- as.data.frame(reg)

-    if (!length(reg_data_frame)){

-        return(GRangesList())

-    }

-    list <- split(reg_data_frame, reg_data_frame[1])

-    seq_name <- c("seqname","start","end","strand",schema)

-    

-    sampleList <- lapply(list, function(x){

-        x <- x[-1]

-        names(x) <- seq_name

+  rows <- as.integer(rows[1])

+  if(rows<0)

+    stop("rows cannot be negative")

+  

+  WrappeR <- J("it/polimi/genomics/r/Wrapper")

+  response <- WrappeR$take(input_data, rows)

+  error <- strtoi(response[1])

+  data <- response[2]

+  if(error)

+    stop(data)

+  

+  reg <- .jevalArray(WrappeR$get_reg(),simplify = TRUE)

+  if(is.null(reg))

+    stop("no regions defined")

+  meta <- .jevalArray(WrappeR$get_meta(),simplify = TRUE)

+  if(is.null(meta))

+    stop("no metadata defined")

+  schema <- .jevalArray(WrappeR$get_schema(),simplify = TRUE)

+  if(is.null(schema))

+    stop("no schema defined")

+  

+  reg_data_frame <- as.data.frame(reg)

+  if (!length(reg_data_frame)){

+    return(GRangesList())

+  }

+  list <- split(reg_data_frame, reg_data_frame[1])

+  seq_name <- c("seqname","start","end","strand",schema)

+  

+  sampleList <- lapply(list, function(x){

+    x <- x[-1]

+    names(x) <- seq_name

     #    start_numeric = as.numeric(levels(x$start))[x$start]

-        start_numeric = as.numeric(x$start)

-        start_numeric = start_numeric + 1

-        x$start =  start_numeric

-        #levels(x$start)[x$start] = start_numeric

-        g <- GenomicRanges::makeGRangesFromDataFrame(x,

-                                    keep.extra.columns = TRUE,

-                                    start.field = "start",

-                                    end.field = "end")

-        })

-    

-    gRange_list <- GRangesList(sampleList)

-    len = length(gRange_list)

-    names(gRange_list) <- paste0("S_",seq_len(len))

-    meta_list <- .metadata_from_frame_to_list(meta)

-    names(meta_list) <- paste0("S_",seq_len(len))

-    S4Vectors::metadata(gRange_list) <- meta_list

-    return(gRange_list)

+    start_numeric = as.numeric(x$start)

+    start_numeric = start_numeric + 1

+    x$start =  start_numeric

+    #levels(x$start)[x$start] = start_numeric

+    g <- GenomicRanges::makeGRangesFromDataFrame(

+      x,

+      keep.extra.columns = TRUE,

+      start.field = "start",

+      end.field = "end")

+  })

+  

+  gRange_list <- GRangesList(sampleList)

+  len = length(gRange_list)

+  names(gRange_list) <- paste0("S_",seq_len(len))

+  meta_list <- .metadata_from_frame_to_list(meta)

+  names(meta_list) <- paste0("S_",seq_len(len))

+  S4Vectors::metadata(gRange_list) <- meta_list

+  return(gRange_list)

 }

 .metadata_from_frame_to_list <- function(metadata_frame) {

-    meta_frame <- as.data.frame(metadata_frame)

-    list <- split(meta_frame, meta_frame[1])

-    name_value_list <- lapply(list, function(x){x <- x[-1]})

-    meta_list <- lapply(name_value_list, function(x){

-        stats::setNames(as.list(as.character(x[[2]])), x[[1]])

-    })

+  meta_frame <- as.data.frame(metadata_frame)

+  list <- split(meta_frame, meta_frame[1])

+  name_value_list <- lapply(list, function(x){x <- x[-1]})

+  meta_list <- lapply(name_value_list, function(x){

+    stats::setNames(as.list(as.character(x[[2]])), x[[1]])

+  })

 }

-

-

old mode 100644

new mode 100755

@@ -35,8 +35,10 @@ execute <- function()

 {

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

     remote_proc <- WrappeR$is_remote_processing()

+    datasets <- .jevalArray(WrappeR$get_dataset_list(),simplify = TRUE)

+    

     if(!remote_proc)

-        .download_or_upload()

+        .download_or_upload(datasets)

     response <- WrappeR$execute()

     error <- strtoi(response[1])

@@ -51,15 +53,14 @@ execute <- function()

                 isGTF <- TRUE

             url <- WrappeR$get_url()

-            .download_or_upload()

+            .download_or_upload(datasets)

             res <- serialize_query(url,isGTF,val)

         }

     }

 }

-.download_or_upload <- function() {

+.download_or_upload <- function(datasets) {

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    datasets <- .jevalArray(WrappeR$get_dataset_list(),simplify = TRUE)

     data_list <- apply(datasets, 1, as.list)

     url <- WrappeR$get_url()

     remote <- WrappeR$is_remote_processing()

@@ -43,10 +43,8 @@ execute <- function()

     val <- response[2]

     if(error)

         stop(val)

-    else

-    {

-        if(remote_proc)

-        {

+    else {

+        if(remote_proc) {

             isGTF <- FALSE

             outformat <- WrappeR$outputMaterialize()

             if(identical(outformat, "gtf"))

@@ -59,29 +57,24 @@ execute <- function()

     }

 }

-.download_or_upload <- function()

-{

+.download_or_upload <- function() {

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

     datasets <- .jevalArray(WrappeR$get_dataset_list(),simplify = TRUE)

     data_list <- apply(datasets, 1, as.list)

     url <- WrappeR$get_url()

     remote <- WrappeR$is_remote_processing()

-    if(remote)

-    {

+    if(remote) {

         lapply(data_list,function(x){

             if(!is.null(x[[1]]) && !is.na(x[[1]]))

                 upload_dataset(url,x[[2]],x[[1]],x[[3]],FALSE)})

-    }

-    else

-    {

+    } else {

         lapply(data_list,function(x){

             if(!is.null(x[[2]]) && !is.na(x[[2]]))

                 download_dataset(url,x[[2]],x[[1]])})

     }

 }

-collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1")

-{

+collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1") {

     ptr_data <- value(x)

     gmql_materialize(ptr_data, dir_out, name)

 }

@@ -137,12 +130,10 @@ collect.GMQLDataset <- function(x, dir_out = getwd(), name = "ds1")

 #' @export

 setMethod("collect", "GMQLDataset",collect.GMQLDataset)

-gmql_materialize <- function(input_data, dir_out, name)

-{

+gmql_materialize <- function(input_data, dir_out, name) {

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

     remote_proc <- WrappeR$is_remote_processing()

-    if(!remote_proc)

-    {

+    if(!remote_proc) {

         dir_out <- sub("/*[/]$","",dir_out)

         res_dir_out <- file.path(dir_out,name)

         if(!dir.exists(res_dir_out))

@@ -226,8 +217,7 @@ setMethod("take", "GMQLDataset",

                 gmql_take(ptr_data, rows)

             })

-gmql_take <- function(input_data, rows)

-{

+gmql_take <- function(input_data, rows) {

     rows <- as.integer(rows[1])

     if(rows<0)

         stop("rows cannot be negative")

@@ -259,9 +249,11 @@ gmql_take <- function(input_data, rows)

     sampleList <- lapply(list, function(x){

         x <- x[-1]

         names(x) <- seq_name

-        start_numeric = as.numeric(levels(x$start))[x$start]

+    #    start_numeric = as.numeric(levels(x$start))[x$start]

+        start_numeric = as.numeric(x$start)

         start_numeric = start_numeric + 1

-        levels(x$start)[x$start] = start_numeric

+        x$start =  start_numeric

+        #levels(x$start)[x$start] = start_numeric

         g <- GenomicRanges::makeGRangesFromDataFrame(x,

                                     keep.extra.columns = TRUE,

                                     start.field = "start",

@@ -277,8 +269,7 @@ gmql_take <- function(input_data, rows)

     return(gRange_list)

 }

-.metadata_from_frame_to_list <- function(metadata_frame)

-{

+.metadata_from_frame_to_list <- function(metadata_frame) {

     meta_frame <- as.data.frame(metadata_frame)

     list <- split(meta_frame, meta_frame[1])

     name_value_list <- lapply(list, function(x){x <- x[-1]})

@@ -250,6 +250,9 @@ gmql_take <- function(input_data, rows)

         stop("no schema defined")

     reg_data_frame <- as.data.frame(reg)

+    if (!length(reg_data_frame)){

+        return(GRangesList())

+    }

     list <- split(reg_data_frame, reg_data_frame[1])

     seq_name <- c("seqname","start","end","strand",schema)

@@ -264,9 +264,12 @@ gmql_take <- function(input_data, rows)

                                     start.field = "start",

                                     end.field = "end")

         })

+    

     gRange_list <- GRangesList(sampleList)

+    len = length(gRange_list)

+    names(gRange_list) <- paste0("S_",seq_len(len))

     meta_list <- .metadata_from_frame_to_list(meta)

-    

+    names(meta_list) <- paste0("S_",seq_len(len))

     S4Vectors::metadata(gRange_list) <- meta_list

     return(gRange_list)

 }