updating PR #368 with a templated Nullable

with a big thanks to Dan

Author: eddelbuettel

inst/include/Rcpp/Nullable.h

@@ -2,7 +2,7 @@
 //
 // Nullable.h: Rcpp R/C++ interface class library -- SEXP container which can be NULL
 //
-// Copyright (C) 2015         Dirk Eddelbuettel
+// Copyright (C) 2015         Dirk Eddelbuettel and Daniel C. Dillon
 //
 // This file is part of Rcpp.
 //
@@ -34,22 +34,45 @@
 
 namespace Rcpp {
 
+    template<class T>
     class Nullable {
+    private:
+        template<class U>
+        friend class InputParameter;
+
+        template<class U>
+        friend class traits::Exporter;
+
     public:
 
         /**
          * Empty no-argument constructor of a Nullable object
          *
-         * set validator to FALSE
+         * Assigns (R's) NULL value, and sets validator to FALSE
+         */
+        inline Nullable() : m_sexp(R_NilValue), m_set(false) {}
+
+        /**
+         * Template constructor of a Nullable object
+         *
+         * Assigns object, and set validator to TRUE
          */
-        inline Nullable() : m_sexp(NULL), m_set(false) {}
+
+        inline Nullable(const T &t) : m_sexp(t),  m_set(true) {}
+
+    protected:
 
         /**
          * Standard constructor of a Nullable object
          *
          * @param SEXP is stored
          */
-        inline Nullable(SEXP t) : m_sexp(t), m_set(true) {}
+        inline Nullable(SEXP t) {
+            m_sexp = t;
+            m_set = true;
+        }
+
+    public:
 
         /**
          * Copy constructor for Nullable object
@@ -68,7 +91,7 @@ namespace Rcpp {
          * @throw 'not initialized' if object has not been set
          */
         inline operator SEXP() {
-            checkIfSet();
+            isSet();
             return m_sexp;
         }
 
@@ -87,7 +110,7 @@ namespace Rcpp {
          *
          * @throw 'not initialized' if object has not been set
          */
-        inline bool isNull() {
+        inline bool isNull() const {
             checkIfSet();
             return Rf_isNull(m_sexp);
         }
@@ -97,21 +120,21 @@ namespace Rcpp {
          *
          * @throw 'not initialized' if object has not been set
          */
-        inline bool isNotNull() {
+        inline bool isNotNull() const {
             return ! isNull();
         }
 
         /**
          * Test function to check if object has been initialized
          *
          */
-        inline bool isSet(void) { return m_set; }
+        inline bool isSet(void) const { return m_set; }
 
     private:
         SEXP m_sexp;
         bool m_set;
 
-        inline void checkIfSet(void) {
+        inline void checkIfSet(void) const {
             if (!m_set) {
                 throw ::Rcpp::exception("Not initialized");
             }

inst/unitTests/cpp/misc.cpp

@@ -157,22 +157,22 @@ void test_stop_variadic() {
 }
 
 // [[Rcpp::export]]
-bool testNullableForNull(Nullable N) {
-    return N.isNull();
+bool testNullableForNull(Nullable<NumericMatrix> M) {
+    return M.isNull();
 }
 
 // [[Rcpp::export]]
-bool testNullableForNotNull(Nullable N) {
-    return N.isNotNull();
+bool testNullableForNotNull(Nullable<NumericMatrix> M) {
+    return M.isNotNull();
 }
 
 // [[Rcpp::export]]
-SEXP testNullableOperator(Nullable N) {
-    return N;
+SEXP testNullableOperator(Nullable<NumericMatrix> M) {
+    return M;
 }
 
 // [[Rcpp::export]]
-SEXP testNullableGet(Nullable N) {
-    return N.get();
+SEXP testNullableGet(Nullable<NumericMatrix> M) {
+    return M.get();
 }
 

inst/unitTests/runit.misc.R

@@ -148,24 +148,24 @@ if (.runThisTest) {
     }
 
     test.NullableForNull <- function() {
-        S <- seq(1, 10)
+        M <- matrix(1:4, 2, 2)
         checkTrue(   testNullableForNull(NULL) )
-        checkTrue( ! testNullableForNull(S) )
+        checkTrue( ! testNullableForNull(M) )
     }
 
     test.NullableForNotNull <- function() {
-        S <- seq(1, 10)
+        M <- matrix(1:4, 2, 2)
         checkTrue( ! testNullableForNotNull(NULL) )
-        checkTrue(   testNullableForNotNull(S) )
+        checkTrue(   testNullableForNotNull(M) )
     }
 
     test.NullableAccessOperator <- function() {
-        S <- seq(1, 10)
-        checkEquals( testNullableOperator(S), S )
+        M <- matrix(1:4, 2, 2)
+        checkEquals( testNullableOperator(M), M )
     }
 
     test.NullableAccessGet <- function() {
-        S <- seq(1, 10)
-        checkEquals( testNullableGet(S), S )
+        M <- matrix(1:4, 2, 2)
+        checkEquals( testNullableGet(M), M )
     }
 }