0.27.1

Author: traversc

ChangeLog

@@ -1,3 +1,6 @@
+Version 0.27.1 (2024-06-04)
+   * Add function `set_trust_promises` to allow for serialization and deserialization of PROMSXP
+
 Version 0.26.3 (2024-05-15)
    * When serializing, eval promises immediately (https://github.com/traversc/qs/issues/94)
    * Return NULL and issue a warning when unserializing a PROMSXP (see https://github.com/traversc/qs/issues/93)

NAMESPACE

@@ -31,6 +31,7 @@ export(qsave_handle)
 export(qsavem)
 export(qserialize)
 export(register_altrep_class)
+export(set_trust_promises)
 export(unregister_altrep_class)
 export(zstd_compress_bound)
 export(zstd_compress_raw)

R/RcppExports.R

@@ -173,6 +173,10 @@ get_altrep_class_info <- function(obj) {
     .Call(`_qs_get_altrep_class_info`, obj)
 }
 
+set_trust_promises <- function(value) {
+    .Call(`_qs_set_trust_promises`, value)
+}
+
 # Register entry points for exported C++ functions
 methods::setLoadAction(function(ns) {
     .Call(`_qs_RcppExport_registerCCallable`)

R/zz_help_files.R

@@ -590,3 +590,20 @@ NULL
 #' @examples
 #' get_altrep_class_info(1:5)
 NULL
+
+#' Allow for serialization/deserialization of promises
+#'
+#' Allow for serialization/deserialization of promises
+#'
+#' @usage set_trust_promises(value)
+#'
+#' @param value a boolean `TRUE` or `FALSE`
+#' @return The previous value of the global variable `trust_promises`
+#' 
+#' @export
+#' @name set_trust_promises
+#'
+#' @examples
+#' set_trust_promises(TRUE)
+NULL
+

inst/include/qs_RcppExports.h

@@ -882,6 +882,26 @@ namespace qs {
         return Rcpp::as<SEXP >(rcpp_result_gen);
     }
 
+    inline bool set_trust_promises(bool value) {
+        typedef SEXP(*Ptr_set_trust_promises)(SEXP);
+        static Ptr_set_trust_promises p_set_trust_promises = NULL;
+        if (p_set_trust_promises == NULL) {
+            validateSignature("bool(*set_trust_promises)(bool)");
+            p_set_trust_promises = (Ptr_set_trust_promises)R_GetCCallable("qs", "_qs_set_trust_promises");
+        }
+        RObject rcpp_result_gen;
+        {
+            rcpp_result_gen = p_set_trust_promises(Shield<SEXP>(Rcpp::wrap(value)));
+        }
+        if (rcpp_result_gen.inherits("interrupted-error"))
+            throw Rcpp::internal::InterruptedException();
+        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
+            throw Rcpp::LongjumpException(rcpp_result_gen);
+        if (rcpp_result_gen.inherits("try-error"))
+            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
+        return Rcpp::as<bool >(rcpp_result_gen);
+    }
+
 }
 
 #endif // RCPP_qs_RCPPEXPORTS_H_GEN_

man/set_trust_promises.Rd

@@ -1497,6 +1497,39 @@ RcppExport SEXP _qs_get_altrep_class_info(SEXP objSEXP) {
     UNPROTECT(1);
     return rcpp_result_gen;
 }
+// set_trust_promises
+bool set_trust_promises(bool value);
+static SEXP _qs_set_trust_promises_try(SEXP valueSEXP) {
+BEGIN_RCPP
+    Rcpp::RObject rcpp_result_gen;
+    Rcpp::traits::input_parameter< bool >::type value(valueSEXP);
+    rcpp_result_gen = Rcpp::wrap(set_trust_promises(value));
+    return rcpp_result_gen;
+END_RCPP_RETURN_ERROR
+}
+RcppExport SEXP _qs_set_trust_promises(SEXP valueSEXP) {
+    SEXP rcpp_result_gen;
+    {
+        rcpp_result_gen = PROTECT(_qs_set_trust_promises_try(valueSEXP));
+    }
+    Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error");
+    if (rcpp_isInterrupt_gen) {
+        UNPROTECT(1);
+        Rf_onintr();
+    }
+    bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen);
+    if (rcpp_isLongjump_gen) {
+        Rcpp::internal::resumeJump(rcpp_result_gen);
+    }
+    Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error");
+    if (rcpp_isError_gen) {
+        SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);
+        UNPROTECT(1);
+        Rf_error("%s", CHAR(rcpp_msgSEXP_gen));
+    }
+    UNPROTECT(1);
+    return rcpp_result_gen;
+}
 
 // validate (ensure exported C++ functions exist before calling them)
 static int _qs_RcppExport_validate(const char* sig) { 
@@ -1545,6 +1578,7 @@ static int _qs_RcppExport_validate(const char* sig) {
         signatures.insert("void(*register_altrep_class)(const std::string&,const std::string&)");
         signatures.insert("void(*unregister_altrep_class)(const std::string&,const std::string&)");
         signatures.insert("SEXP(*get_altrep_class_info)(SEXP)");
+        signatures.insert("bool(*set_trust_promises)(bool)");
     }
     return signatures.find(sig) != signatures.end();
 }
@@ -1594,6 +1628,7 @@ RcppExport SEXP _qs_RcppExport_registerCCallable() {
     R_RegisterCCallable("qs", "_qs_register_altrep_class", (DL_FUNC)_qs_register_altrep_class_try);
     R_RegisterCCallable("qs", "_qs_unregister_altrep_class", (DL_FUNC)_qs_unregister_altrep_class_try);
     R_RegisterCCallable("qs", "_qs_get_altrep_class_info", (DL_FUNC)_qs_get_altrep_class_info_try);
+    R_RegisterCCallable("qs", "_qs_set_trust_promises", (DL_FUNC)_qs_set_trust_promises_try);
     R_RegisterCCallable("qs", "_qs_RcppExport_validate", (DL_FUNC)_qs_RcppExport_validate);
     return R_NilValue;
 }
@@ -1642,6 +1677,7 @@ static const R_CallMethodDef CallEntries[] = {
     {"_qs_register_altrep_class", (DL_FUNC) &_qs_register_altrep_class, 2},
     {"_qs_unregister_altrep_class", (DL_FUNC) &_qs_unregister_altrep_class, 2},
     {"_qs_get_altrep_class_info", (DL_FUNC) &_qs_get_altrep_class_info, 1},
+    {"_qs_set_trust_promises", (DL_FUNC) &_qs_set_trust_promises, 1},
     {"_qs_RcppExport_registerCCallable", (DL_FUNC) &_qs_RcppExport_registerCCallable, 0},
     {NULL, NULL, 0}
 };

src/RcppExports.cpp

@@ -225,6 +225,8 @@ enum class qstype {NUMERIC, INTEGER, LOGICAL, CHARACTER, NIL, LIST, COMPLEX, RAW
                    S4, S4FLAG, LOCKED_ENV, UNLOCKED_ENV, REFERENCE,
                    ATTRIBUTE, RSERIALIZED};
 
+// global variable to trust promises for both serialization and de-serialization
+static bool trust_promises_global = false;
 
 ///////////////////////////////////////////////////////
 // There are three types of output input streams -- std::ifstream/ofstream, file descriptor, windows handle

src/qs_common.h

@@ -646,7 +646,7 @@ SEXP processBlock(T * const sobj) {
     SET_S4_OBJECT(obj);
     // SET_OBJECT(obj, 1); // this flag seems kind of pointless
   }
-  if(TYPEOF(obj) == PROMSXP) {
+  if( !trust_promises_global && (TYPEOF(obj) == PROMSXP)) {
     Rcpp::warning("PROMSXP detected, replacing with NULL (see https://github.com/traversc/qs/issues/93)");
     return R_NilValue;
   } else {

src/qs_deserialize_common.h

@@ -844,6 +844,13 @@ SEXP get_altrep_class_info(SEXP obj) {
 #endif
 }
 
+// [[Rcpp::export(rng = false)]]
+bool set_trust_promises(bool value) {
+  bool previous_value = trust_promises_global;
+  trust_promises_global = value;
+  return previous_value;
+}
+
 
 // std::vector<unsigned char> brotli_compress_raw(RawVector x, int compress_level) {
 //   uint64_t zsize = BrotliEncoderMaxCompressedSize(x.size());