Fixes and updates to the attributes parser (#117)

Author: kevinushey

ChangeLog

@@ -1,3 +1,11 @@
+2014-02-17  Kevin Ushey <[email protected]>
+
+        * src/attributes.cpp: Fix attributes behavior with
+        ::create, and also add an option for a default constructor
+        (e.g. NumericVector v = NumericVector(10)) gives a default
+        value of 'numeric(10)' at the R level). Also make NAs
+        keep their type when exposed to R.
+
 2014-02-16  JJ Allaire <[email protected]>
 
         * src/attributes.cpp Replace (incorrect) call to 

inst/NEWS.Rd

@@ -19,7 +19,13 @@
     \item Changes in Rcpp Attributes
       \itemize{
         \item Fix issue preventing packages with Rcpp::interfaces attribute
-      from compiling.
+        from compiling.
+        \item Fix behavior with attributes parsing of ::create for default
+        arguments, and also allow constructors of a given size
+        (e.g. NumericVector v = NumericVector(10)) gives a default
+        value of 'numeric(10)' at the R level). Also make NAs preserve
+        type when exported to R (e.g. NA_STRING as a default argument
+        maps to NA_character_ at the R level)
       }
   }
 }

src/attributes.cpp

@@ -2016,16 +2016,18 @@ namespace attributes {
 
             std::string args = cppArg.substr(createLoc + create.length());
             if (type == "CharacterVector")
-                return "character" + args;
-            else if (type == "IntegerVector")
-                return "integer" + args;
-            else if (type == "NumericVector")
-                return "numeric" + args;
-            else    
-                return std::string();
+                return "as.character( c" + args + ")";
+            if (type == "IntegerVector")
+                return "as.integer( c" + args + ")";
+            if (type == "NumericVector")
+                return "as.numeric( c" + args + ")";
+            if (type == "LogicalVector")
+                return "as.logical( c" + args + ")";
+                    
+            return std::string();
         }
 
-        // convert a C++ Matrix to an R argument (returns emtpy string
+        // convert a C++ Matrix to an R argument (returns empty string
         // if no conversion possible)
         std::string cppMatrixArgToRArg(const std::string& cppArg) {
 
@@ -2041,7 +2043,7 @@ namespace attributes {
             return "matrix" + args;
         }
 
-        // convert a C++ literal to an R argument (returns emtpy string
+        // convert a C++ literal to an R argument (returns empty string
         // if no conversion possible)
         std::string cppLiteralArgToRArg(const std::string& cppArg) {
             if (cppArg == "true")
@@ -2050,14 +2052,46 @@ namespace attributes {
                 return "FALSE";
             else if (cppArg == "R_NilValue")
                 return "NULL";
-            else if (cppArg == "NA_STRING" || cppArg == "NA_INTEGER" ||
-                     cppArg == "NA_LOGICAL" || cppArg == "NA_REAL") {
-                return "NA";
-            }
+            else if (cppArg == "NA_STRING")
+                return "NA_character_";
+            else if (cppArg == "NA_INTEGER")
+                return "NA_integer_";
+            else if (cppArg == "NA_LOGICAL")
+                return "NA_integer_";
+            else if (cppArg == "NA_REAL")
+                return "NA_real_";
             else
                 return std::string();
         }
 
+        // convert an Rcpp container constructor to an R argument
+        // (returns empty string if no conversion possible)
+        std::string cppConstructorArgToRArg(const std::string& cppArg) {
+            
+            // map Rcpp containers to R default initializers
+            static const std::map<std::string, std::string> RcppContainerToR = {
+                {"NumericVector", "numeric"},
+                {"DoubleVector", "numeric"},
+                {"CharacterVector", "character"},
+                {"IntegerVector", "integer"},
+                {"LogicalVector", "logical"},
+                {"ComplexVector", "complex"}
+            };
+            
+            // for each entry in the map above, see if we find it; if we do,
+            // return the R version
+            typedef std::map<std::string, std::string>::const_iterator Iterator;
+            for (Iterator it = RcppContainerToR.begin(); it != RcppContainerToR.end(); ++it) {
+                size_t loc = cppArg.find(it->first);
+                if (loc != std::string::npos) {
+                    return it->second + cppArg.substr(it->first.size(), std::string::npos);
+                }
+            }
+            
+            return std::string();
+            
+        }
+        
         // convert a C++ argument value to an R argument value (returns empty
         // string if no conversion is possible)
         std::string cppArgToRArg(const std::string& type,
@@ -2087,6 +2121,11 @@ namespace attributes {
             if (!rArg.empty())
                 return rArg;
 
+            // try for a constructor arg
+            rArg = cppConstructorArgToRArg(cppArg);
+            if (!rArg.empty())
+                return rArg;
+                
             // couldn't parse the arg
             return std::string();
         }