old mode 100644

new mode 100755

@@ -8,8 +8,7 @@

 #' @noRd

 #' @return instance of GMQL dataset

 #' 

-setClass("GMQLDataset",

-            representation(value = "character"))

+setClass("GMQLDataset", representation(value = "character"))

 #' GMQLDataset alloc Function

 #' 

@@ -22,19 +21,16 @@ setClass("GMQLDataset",

 #' @rdname GMQLDataset-class

 #' @noRd

 GMQLDataset <- function(value) {

-    dataset <- new("GMQLDataset",value = value)

-    return(dataset)

+  dataset <- new("GMQLDataset",value = value)

+  return(dataset)

 }

-setMethod("show", "GMQLDataset",

-            function(object)

-            {

-                cat("GMQL Dataset \n")

-                cat(" value :",paste(object@value))

-            })

+setMethod("show", "GMQLDataset", function(object) {

+  cat("GMQL Dataset \n")

+  cat(" value :",paste(object@value))

+})

 setGeneric("value", function(.dataset) standardGeneric("value"))

 setMethod("value", "GMQLDataset", function(.dataset) .dataset@value)

-

old mode 100644

new mode 100755

@@ -18,7 +18,6 @@ setGeneric("cover", function(.data, ...) standardGeneric("cover"))

 #' 

 setGeneric("map", function(x, y, ...) standardGeneric("map"))

-

 #' Method take

 #' 

 #' Wrapper to TAKE operation

@@ -29,7 +28,6 @@ setGeneric("map", function(x, y, ...) standardGeneric("map"))

 #' 

 setGeneric("take", function(.data, ...) standardGeneric("take"))

-

 #' Method extend

 #' 

 #' Wrapper to GMQL EXTEND operator 

old mode 100644

new mode 100755

@@ -32,23 +32,23 @@

 #' @rdname condition_eval_func

 #' @export

 conds <- function(default = c(""), full = c(""), exact = c("")) {

-    df <- .condition("DEF",default)

-    fn <- .condition("FULL",full)

-    ex <- .condition("EXACT",exact)

-    list("condition" = list("def" = df, "full" = fn, "exact" = ex))

+  df <- .condition("DEF",default)

+  fn <- .condition("FULL",full)

+  ex <- .condition("EXACT",exact)

+  list("condition" = list("def" = df, "full" = fn, "exact" = ex))

 }

 .condition <- function(cond, array) {

-    array = array[!array %in% ""]

-    array = array[!duplicated(array)]

-    

-    if(!length(array))

-        join_condition_matrix <- NULL

-    else {

-        join_condition_matrix <- t(vapply(array, function(x) {

-            new_value = c(cond, x)

-            matrix <- matrix(new_value)

-        },character(2)))

-    }

-    join_condition_matrix

+  array = array[!array %in% ""]

+  array = array[!duplicated(array)]

+  

+  if(!length(array))

+    join_condition_matrix <- NULL

+  else {

+    join_condition_matrix <- t(vapply(array, function(x) {

+      new_value = c(cond, x)

+      matrix <- matrix(new_value)

+    },character(2)))

+  }

+  join_condition_matrix

 }

old mode 100644

new mode 100755

@@ -122,90 +122,87 @@

 #' @aliases cover,GMQLDataset-method

 #' @aliases cover-method

 #' @export

-setMethod("cover", "GMQLDataset",

-            function(.data, min_acc, max_acc, groupBy = conds(), 

-                    variation = "cover", ...)

-            {

-                val <- value(.data)

-                s_min <- substitute(min_acc)

-                s_min <- .trasform_cover(deparse(s_min))                

-                s_max <- substitute(max_acc)

-                s_max <- .trasform_cover(deparse(s_max))

-                

-                q_max <- .check_cover_param(s_max,FALSE)

-                q_min <- .check_cover_param(s_min,TRUE)

-                

-                flag = toupper(variation)

-                aggregates = list(...)

-                gmql_cover(val, q_min, q_max, groupBy, aggregates, flag)

-            })

-

-gmql_cover <- function(input_data, min_acc, max_acc, groupBy,aggregates,flag)

+setMethod("cover", "GMQLDataset", function(

+  .data, min_acc, max_acc, groupBy = conds(), variation = "cover", ...)

 {

-    if(!is.null(groupBy))

-    {

-        if("condition" %in% names(groupBy))

-        {

-            cond <- .join_condition(groupBy)

-            if(is.null(cond))

-                join_matrix <- .jnull("java/lang/String")

-            else

-                join_matrix <- .jarray(cond, dispatch = TRUE)

-        }

-        else

-            stop("use function conds()")

-    }

-    else

-        join_matrix <- .jnull("java/lang/String")

+  val <- value(.data)

+  s_min <- substitute(min_acc)

+  s_min <- .trasform_cover(deparse(s_min))                

+  s_max <- substitute(max_acc)

+  s_max <- .trasform_cover(deparse(s_max))

+  

+  q_max <- .check_cover_param(s_max,FALSE)

+  q_min <- .check_cover_param(s_min,TRUE)

+  

+  flag = toupper(variation)

+  aggregates = list(...)

+  gmql_cover(val, q_min, q_max, groupBy, aggregates, flag)

+})

-    if(!is.null(aggregates) && length(aggregates))

-    {

-        aggr <- .aggregates(aggregates,"AGGREGATES")

-        metadata_matrix <- .jarray(aggr, dispatch = TRUE)

+gmql_cover <- function(

+  input_data, 

+  min_acc, 

+  max_acc, 

+  groupBy,

+  aggregates,

+  flag

+) {

+  if(!is.null(groupBy)) {

+    if("condition" %in% names(groupBy)) {

+      cond <- .join_condition(groupBy)

+      if(is.null(cond))

+        join_matrix <- .jnull("java/lang/String")

+      else

+        join_matrix <- .jarray(cond, dispatch = TRUE)

     }

     else

-        metadata_matrix <- .jnull("java/lang/String")

-    

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

-    response <- switch(flag,

-        "COVER" = WrappeR$cover(min_acc, max_acc, join_matrix,

-                                    metadata_matrix, input_data),

-        "FLAT" = WrappeR$flat(min_acc, max_acc, join_matrix,

-                                    metadata_matrix, input_data),

-        "SUMMIT" = WrappeR$summit(min_acc,max_acc, join_matrix,

-                                    metadata_matrix, input_data),

-        "HISTOGRAM" = WrappeR$histogram(min_acc, max_acc, join_matrix, 

-                                    metadata_matrix, input_data))

-    if(is.null(response))

-        stop("no admissible variation: cover, flat, summit, histogram")

-    

-    error <- strtoi(response[1])

-    val <- response[2]

-    if(error)

-        stop(val)

-    else

-        GMQLDataset(val)

+      stop("use function conds()")

+  } else

+    join_matrix <- .jnull("java/lang/String")

+  

+  if(!is.null(aggregates) && length(aggregates)) {

+    aggr <- .aggregates(aggregates,"AGGREGATES")

+    metadata_matrix <- .jarray(aggr, dispatch = TRUE)

+  } else

+    metadata_matrix <- .jnull("java/lang/String")

+  

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

+  response <- switch(

+    flag,

+    "COVER" = WrappeR$cover(

+      min_acc, max_acc, join_matrix, metadata_matrix, input_data),

+    "FLAT" = WrappeR$flat(

+      min_acc, max_acc, join_matrix,metadata_matrix, input_data),

+    "SUMMIT" = WrappeR$summit(

+      min_acc,max_acc, join_matrix, metadata_matrix, input_data),

+    "HISTOGRAM" = WrappeR$histogram(

+      min_acc, max_acc, join_matrix, metadata_matrix, input_data)

+  )

+  if(is.null(response))

+    stop("no admissible variation: cover, flat, summit, histogram")

+  

+  error <- strtoi(response[1])

+  val <- response[2]

+  if(error)

+    stop(val)

+  else

+    GMQLDataset(val)

 }

-.check_cover_param <- function(param, is_min)

-{

-    if(length(param) > 1)

-        stop("length > 1")

-

-    if(is.character(param))

-    {

-        if(is_min && identical(param,"ANY"))

-            stop("min cannot assume ANY as value")

-        

-        return(param)

-    }

-    else

-        stop("invalid input data")

+.check_cover_param <- function(param, is_min) {

+  if(length(param) > 1)

+    stop("length > 1")

+  

+  if(is.character(param)) {

+    if(is_min && identical(param,"ANY"))

+      stop("min cannot assume ANY as value")

+    return(param)

+  } else

+    stop("invalid input data")

 }

-.trasform_cover <- function(predicate)

-{

+.trasform_cover <- function(predicate) {

     predicate <- gsub("\\(\\)","",predicate)

 }

old mode 100644

new mode 100755

@@ -61,36 +61,34 @@

 #' @aliases setdiff,GMQLDataset,GMQLDataset-method

 #' @aliases setdiff-method

 #' @export

-setMethod("setdiff", c("GMQLDataset","GMQLDataset"),

-            function(x, y, joinBy = conds(), is_exact = FALSE)

-            {

-                ptr_data_x = value(x)

-                ptr_data_y = value(y)

-                gmql_difference(ptr_data_x, ptr_data_y, is_exact, joinBy)

-            })

+setMethod("setdiff", c("GMQLDataset","GMQLDataset"), 

+  function(x, y, joinBy = conds(), is_exact = FALSE) {

+    ptr_data_x = value(x)

+    ptr_data_y = value(y)

+    gmql_difference(ptr_data_x, ptr_data_y, is_exact, joinBy)

+  })

-gmql_difference <- function(left_data, right_data, is_exact, joinBy)

-{

-    if(!is.null(joinBy))

-    {

-        cond <- .join_condition(joinBy)

-        if(is.null(cond))

-            join_matrix <- .jnull("java/lang/String")

-        else

-            join_matrix <- .jarray(cond, dispatch = TRUE)

-    }

+gmql_difference <- function(left_data, right_data, is_exact, joinBy) {

+  if(!is.null(joinBy)) {

+    cond <- .join_condition(joinBy)

+    if(is.null(cond))

+      join_matrix <- .jnull("java/lang/String")

     else

-        join_matrix <- .jnull("java/lang/String")

-    

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

-    response <- WrappeR$difference(join_matrix, left_data, right_data, 

-                                        is_exact)

-    error <- strtoi(response[1])

-    val <- response[2]

-    if(error)

-        stop(val)

-    else

-        GMQLDataset(val)

+      join_matrix <- .jarray(cond, dispatch = TRUE)

+  }

+  else

+    join_matrix <- .jnull("java/lang/String")

+  

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

+  response <- WrappeR$difference(

+    join_matrix, left_data, right_data, is_exact

+  )

+  error <- strtoi(response[1])

+  val <- response[2]

+  if(error)

+    stop(val)

+  else

+    GMQLDataset(val)

 }

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

old mode 100644

new mode 100755

@@ -66,82 +66,93 @@

 #' @rdname read-function

 #' @export

 #'

-read_gmql <- function(dataset, parser = "CustomParser", is_local = TRUE, 

-                            is_GMQL = TRUE)

-{

-    .check_input(dataset)

-    .check_logical(is_local)

-    .check_logical(is_GMQL)

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

-    parser_name <- .check_parser(parser)

-    if(is_local)

-    {

-        if(!dir.exists(dataset))

-            stop("folder does not exist")

-        

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

-        if(basename(dataset) !="files")

-            dataset <- file.path(dataset,"files")

-        

-        schema_SCHEMA <- list.files(dataset, pattern = "*.schema$",

-                                        full.names = TRUE)

-        

-        xml_schema <- list.files(dataset, pattern = "*.xml$",

-                                        full.names = TRUE)

-        xml_schema = xml_schema[!basename(xml_schema) %in% c("web_profile.xml")]

-        

-        if(!length(schema_SCHEMA) && !length(xml_schema))

-            stop("schema not present")

-        

-        if(!length(schema_SCHEMA))

-            schema_XML <- xml_schema

-        else

-            schema_XML <- dataset

-        

-        schema_matrix <- .jnull("java/lang/String")

-        url <- .jnull("java/lang/String")

-        coords_sys <- .jnull("java/lang/String")

-        type <- .jnull("java/lang/String")

-    }

+read_gmql <- function(

+  dataset, 

+  parser = "CustomParser", 

+  is_local = TRUE, 

+  is_GMQL = TRUE

+) {

+  .check_input(dataset)

+  .check_logical(is_local)

+  .check_logical(is_GMQL)

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

+  parser_name <- .check_parser(parser)

+  if(is_local) {

+    if(!dir.exists(dataset))

+      stop("folder does not exist")

+    

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

+    if(basename(dataset) !="files")

+      dataset <- file.path(dataset,"files")

+    

+    schema_SCHEMA <- list.files(

+      dataset, pattern = "*.schema$", full.names = TRUE

+    )

+    

+    xml_schema <- list.files(

+      dataset, pattern = "*.xml$", full.names = TRUE

+    )

+    xml_schema = xml_schema[!basename(xml_schema) %in% c("web_profile.xml")]

+    

+    if(!length(schema_SCHEMA) && !length(xml_schema))

+      stop("schema not present")

+    

+    if(!length(schema_SCHEMA))

+      schema_XML <- xml_schema

     else

-    {

-        url <- WrappeR$get_url()

-        if(is.null(url))

-            stop("You have to log on using login function")

-        

-        if(!exists("GMQL_credentials", envir = .GlobalEnv))

-            stop("You have to log on using login function")

-        

-        if(identical(parser_name,"CUSTOMPARSER"))

-        {

-            list <- show_schema(url,dataset)

-            coords_sys <- list$coordinate_system

-            type <- list$type

-            schema_names <- vapply(list$fields, function(x){x$name},

-                                        character(1))

-            schema_type <- vapply(list$fields, function(x){x$type},

-                                        character(1))

-            schema_matrix <- cbind(schema_names,schema_type)

-

-            if(is.null(schema_matrix) || !length(schema_matrix))

-                schema_matrix <- .jnull("java/lang/String")

-            else

-                schema_matrix <- .jarray(schema_matrix, dispatch = TRUE)

-        }

-        else

-            schema_matrix <- .jnull("java/lang/String")

-        

-        schema_XML <- .jnull("java/lang/String")

+      schema_XML <- dataset

+    

+    schema_matrix <- .jnull("java/lang/String")

+    url <- .jnull("java/lang/String")

+    coords_sys <- .jnull("java/lang/String")

+    type <- .jnull("java/lang/String")

+  } else {

+    url <- WrappeR$get_url()

+    if(is.null(url))

+      stop("You have to log on using login function")

+    

+    if(!exists("GMQL_credentials", envir = .GlobalEnv))

+      stop("You have to log on using login function")

+    

+    if(identical(parser_name,"CUSTOMPARSER")) {

+      list <- show_schema(url,dataset)

+      coords_sys <- list$coordinate_system

+      type <- list$type

+      schema_names <- vapply(

+        list$fields, function(x){x$name},character(1)

+      )

+      schema_type <- vapply(

+        list$fields, function(x){x$type},character(1)

+      )

+      schema_matrix <- cbind(schema_names,schema_type)

+      

+      if(is.null(schema_matrix) || !length(schema_matrix))

+        schema_matrix <- .jnull("java/lang/String")

+      else

+        schema_matrix <- .jarray(schema_matrix, dispatch = TRUE)

     }

-

-    response <- WrappeR$readDataset(dataset, parser_name, is_local, is_GMQL, 

-                    schema_matrix, schema_XML, coords_sys, type)

-    error <- strtoi(response[1])

-    data <- response[2]

-    if(error)

-        stop(data)

     else

-        GMQLDataset(data)

+      schema_matrix <- .jnull("java/lang/String")

+    

+    schema_XML <- .jnull("java/lang/String")

+  }

+  

+  response <- WrappeR$readDataset(

+    dataset, 

+    parser_name, 

+    is_local, 

+    is_GMQL, 

+    schema_matrix,

+    schema_XML,

+    coords_sys, 

+    type

+  )

+  error <- strtoi(response[1])

+  data <- response[2]

+  if(error)

+    stop(data)

+  else

+    GMQLDataset(data)

 }

@@ -154,81 +165,89 @@ read_gmql <- function(dataset, parser = "CustomParser", is_local = TRUE,

 #' @rdname read-function

 #' @export

 #'

-read_GRangesList <- function(samples)

-{

-    if(!is(samples,"GRangesList"))

-        stop("only GrangesList")

-    

-    meta <- S4Vectors::metadata(samples)

-    if(is.null(meta) || !length(meta)) 

-    {

-        #repeat meta for each sample in samples list

-        len <- length(samples)

-        warning("No metadata.\nWe provide two metadata for you:

-                \n1.provider = PoliMi\n2.application = RGMQL\n")

-        index_meta <- rep(seq_len(len),each = len)

-        rep_meta <- rep(c("provider","PoliMi", "application", "RGMQL"),

-                            times = len)

-        meta_matrix <- matrix(rep_meta,ncol = 2,byrow = TRUE)

-        meta_matrix <- cbind(index_meta,meta_matrix)

-    }

-    else 

-    {

-        unlist_meta <- unlist(meta)

-        names_meta <- names(unlist_meta)

-        group_names <- gsub(".*_([0-9]*)\\..*","\\1", names_meta)

-        names(unlist_meta) <- NULL

-        meta_matrix <- cbind(group_names,names_meta,unlist_meta)

-    }

-    

-    df <- data.frame(samples)

-    df <- df[-2] #delete group_name

-    len_df <- dim(df)[1] # number of rows

-

-    col_types <- vapply(df,class,character(1))

-    col_names <- names(col_types)

-    #re order the schema?

-    if("phase" %in% col_names) # if GTF, change

-    {

-        col_names <- plyr::revalue(col_names,c(type = "feature", 

-                                    phase = "frame", seqnames = "seqname"))

-        schema_matrix <- cbind(toupper(col_types),col_names)

-        schema_matrix<- schema_matrix[setdiff(rownames(schema_matrix),

-                                        c("group","width")),]

-    }

-    else

-    {

-        col_names <- plyr::revalue(col_names,c(start = "left", 

-                                        end = "right", seqnames = "chr"))

-        schema_matrix <- cbind(col_names,toupper(col_types))

-        df$start = df$start - 1

-        schema_matrix<- schema_matrix[setdiff(rownames(schema_matrix),

-                                        c("group","width")),]

-    }

-    region_matrix <- as.matrix(vapply(df, as.character,character(len_df)))

-    region_matrix[is.na(region_matrix)] <- "NA"

-    region_matrix <- region_matrix[,setdiff(colnames(region_matrix),"width")]

-    rownames(schema_matrix) <- NULL

-    colnames(schema_matrix) <- NULL

-    

-    schema_matrix <- .jarray(schema_matrix,dispatch = TRUE)

-    meta_matrix <- .jarray(meta_matrix,dispatch = TRUE)

-    region_matrix <- .jarray(region_matrix,dispatch = TRUE)

-    

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

-    response <- WrappeR$read(meta_matrix,region_matrix,schema_matrix,

-                                "default", "TAB")

-    GMQLDataset(response)

+read_GRangesList <- function(samples) {

+  if(!is(samples,"GRangesList"))

+    stop("only GrangesList")

+  

+  meta <- S4Vectors::metadata(samples)

+  if(is.null(meta) || !length(meta)) {

+    #repeat meta for each sample in samples list

+    len <- length(samples)

+    warning(

+    "No metadata.\nWe provide two metadata for you:

+    \n1.provider = PoliMi\n2.application = RGMQL\n"

+    )

+    index_meta <- rep(seq_len(len),each = len)

+    rep_meta <- rep(

+      c("provider","PoliMi", "application", "RGMQL"),

+      times = len

+    )

+    meta_matrix <- matrix(rep_meta,ncol = 2,byrow = TRUE)

+    meta_matrix <- cbind(index_meta,meta_matrix)

+  }else {

+    unlist_meta <- unlist(meta)

+    names_meta <- names(unlist_meta)

+    group_names <- gsub(".*_([0-9]*)\\..*","\\1", names_meta)

+    names(unlist_meta) <- NULL

+    meta_matrix <- cbind(group_names,names_meta,unlist_meta)

+  }

+  

+  df <- data.frame(samples)

+  df <- df[-2] #delete group_name

+  len_df <- dim(df)[1] # number of rows

+  

+  col_types <- vapply(df,class,character(1))

+  col_names <- names(col_types)

+  #re order the schema?

+  # if GTF, change

+  if("phase" %in% col_names) {

+    col_names <- plyr::revalue(

+      col_names,c(type = "feature", phase = "frame", seqnames = "seqname")

+    )

+    schema_matrix <- cbind(toupper(col_types),col_names)

+    schema_matrix<- schema_matrix[

+      setdiff(rownames(schema_matrix), c("group","width")),]

+  } else {

+    col_names <- plyr::revalue(

+      col_names,

+      c(start = "left", end = "right", seqnames = "chr"))

+    schema_matrix <- cbind(col_names,toupper(col_types))

+    df$start = df$start - 1

+    schema_matrix<- schema_matrix[

+      setdiff(rownames(schema_matrix),c("group","width")),]

+  }

+  region_matrix <- as.matrix(vapply(df, as.character,character(len_df)))

+  region_matrix[is.na(region_matrix)] <- "NA"

+  region_matrix <- region_matrix[,setdiff(colnames(region_matrix),"width")]

+  rownames(schema_matrix) <- NULL

+  colnames(schema_matrix) <- NULL

+  

+  schema_matrix <- .jarray(schema_matrix,dispatch = TRUE)

+  meta_matrix <- .jarray(meta_matrix,dispatch = TRUE)

+  region_matrix <- .jarray(region_matrix,dispatch = TRUE)

+  

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

+  response <- WrappeR$read(

+    meta_matrix,

+    region_matrix,

+    schema_matrix,

+    "default", "TAB"

+  )

+  

+  GMQLDataset(response)

 }

-

-.check_parser <- function(parser)

-{

-    parser <- toupper(parser)

-    if(!parser %in% c("BEDPARSER","BROADPEAKPARSER", "NARROWPEAKPARSER",

-                        "CUSTOMPARSER"))

-        stop("parser not defined")

-    

-    parser

+.check_parser <- function(parser) {

+  parser <- toupper(parser)

+  parsers <- c(

+    "BEDPARSER",

+    "BROADPEAKPARSER",

+    "NARROWPEAKPARSER",

+    "CUSTOMPARSER")

+  

+  if(!parser %in% parsers)

+    stop("parser not defined")

+  

+  parser

 }

old mode 100644

new mode 100755

@@ -1,17 +1,14 @@

-if(getRversion() >= "2.15.1")

-{

-    utils::globalVariables("GMQL_credentials")

-    utils::globalVariables("remote_url")

+if(getRversion() >= "2.15.1") {

+  utils::globalVariables("GMQL_credentials")

+  utils::globalVariables("remote_url")

 }

-if(getRversion() >= "3.1.0")

-{

-    utils::suppressForeignCheck("GMQL_credentials")

-    utils::suppressForeignCheck("remote_url")

+if(getRversion() >= "3.1.0") {

+  utils::suppressForeignCheck("GMQL_credentials")

+  utils::suppressForeignCheck("remote_url")

 }

-

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

 #     WEB AUTHENTICATION   #

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

@@ -52,10 +49,8 @@ if(getRversion() >= "3.1.0")

 #' @rdname login_gmql

 #' @export

 #' 

-login_gmql <- function(url, username = NULL, password = NULL)

-{

-    if(!.is_login_expired(url))

-    {

+login_gmql <- function(url, username = NULL, password = NULL) {

+    if(!.is_login_expired(url)) {

         print("Login still valid")

         return(invisible(NULL))

     }

@@ -65,8 +60,7 @@ login_gmql <- function(url, username = NULL, password = NULL)

     if(!is.null(username) || !is.null(password))

         as_guest <- FALSE

-    if(as_guest)

-    {

+    if(as_guest) {

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

         h <- c('Accept' = "Application/json")

         URL <- paste0(url,"/guest")

@@ -836,8 +830,7 @@ show_samples_list <- function(url,datasetName)

 #' @rdname show_schema

 #' @export

 #'

-show_schema <- function(url,datasetName)

-{

+show_schema <- function(url,datasetName) {

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

     URL <- paste0(url,"/datasets/",datasetName,"/schema")

     authToken = GMQL_credentials$authToken

@@ -977,7 +970,7 @@ upload_dataset <- function(url, datasetName, folderPath, schemaName = NULL,

     req <- httr::POST(URL, body = list_files ,httr::add_headers(h))

     content <- httr::content(req)

     if(req$status_code !=200)

-        print(content)

+        stop(content)

     else

         print("upload Complete")

 }

@@ -1082,7 +1075,7 @@ download_dataset <- function(url, datasetName, path = getwd())

     content <- httr::content(req)

     if(req$status_code !=200)

-        print(content)

+        stop(content)

     else

     {

         zip_path <- file.path(path,paste0(datasetName,".zip"))