add MapCompare + #defines so map works when using std::map

Author: kevinushey

inst/include/Rcpp/sugar/functions/table.h

@@ -21,22 +21,25 @@
 
 #ifndef Rcpp__sugar__table_h
 #define Rcpp__sugar__table_h
+
+#ifdef RCPP_USING_MAP
+#include <Rcpp/sugar/tools/mapcompare.h>
+#endif
 
 namespace Rcpp{
 namespace sugar{
 
 template <typename HASH, typename STORAGE>
 class CountInserter {
 public:
-    CountInserter( HASH& hash_ ) : hash(hash_), index(0) {}
+    CountInserter( HASH& hash_ ) : hash(hash_) {}
 
     inline void operator()( STORAGE value ){
         hash[value]++ ;
     }
 
 private:
     HASH& hash ;
-    int index;
 } ; 
 
 template <typename HASH, int RTYPE>
@@ -63,9 +66,11 @@ class Table {
 
     Table( const TABLE_T& table ): hash(), map() {
         // populate the initial hash
+        Rprintf("populating hash\n");
         std::for_each( table.begin(), table.end(), Inserter(hash) ) ;
 
         // populate the map, sorted by keys
+        Rprintf("populating map\n");
         map.insert( hash.begin(), hash.end() ) ;
     }
 
@@ -80,7 +85,13 @@ class Table {
     }
 
 private:
-    typedef RCPP_UNORDERED_MAP<STORAGE, int> HASH ;
+    // bugfix for standard map
+    #ifdef RCPP_USING_MAP
+      typedef RCPP_UNORDERED_MAP<STORAGE, int, MapCompare<STORAGE> >HASH ;
+    #else
+      typedef RCPP_UNORDERED_MAP<STORAGE, int> HASH ;
+    #endif
+    
     typedef CountInserter<HASH,STORAGE> Inserter ;
 
     typedef std::map<STORAGE, int, typename Rcpp::traits::comparator_type<RTYPE>::type > SORTED_MAP ;

inst/include/Rcpp/sugar/tools/mapcompare.h

@@ -0,0 +1,92 @@
+// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*-
+//
+// table.h: Rcpp R/C++ interface class library -- table match
+//
+// Copyright (C) 2012   Dirk Eddelbuettel and Romain Francois
+//
+// This file is part of Rcpp.
+//
+// Rcpp is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 2 of the License, or
+// (at your option) any later version.
+//
+// Rcpp is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Rcpp.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef Rcpp__sugar__tools__mapcompare_h
+#define Rcpp__sugar__tools__mapcompare_h
+
+#define R_UNSIGNED_LONG_NAN_REAL 0x7ff8000000000000
+
+namespace Rcpp {
+namespace sugar {
+
+inline bool Rcpp_IsNA(double x) {
+  return *reinterpret_cast<unsigned long*>(&x) == *reinterpret_cast<unsigned long*>(&NA_REAL);
+}
+
+inline bool Rcpp_IsNaN(double x) {
+  return *reinterpret_cast<unsigned long*>(&x) == R_UNSIGNED_LONG_NAN_REAL;
+}
+
+inline int StrCmp(SEXP x, SEXP y) {
+    if (x == NA_STRING) return (y == NA_STRING ? 0 : 1);
+    if (y == NA_STRING) return -1;
+    if (x == y) return 0;  // same string in cache
+    return strcmp(CHAR(x), CHAR(y));
+}
+
+template <typename T>
+struct MapCompare {
+  inline bool operator()(T left, T right) const {
+    return left < right;
+  }
+};
+
+template <>
+struct MapCompare<int> {
+  inline bool operator()(int left, int right) const {
+    if (left == NA_INTEGER) return false;
+    if (right == NA_INTEGER) return true;
+    return left < right;
+  }
+};
+
+template <>
+struct MapCompare<double> {  
+  inline bool operator()(double left, double right) const {
+        
+    bool leftNaN = (left != left);
+    bool rightNaN = (right != right);
+    
+    // this branch inspired by data.table: see
+    // https://github.com/arunsrinivasan/datatable/commit/1a3e476d3f746e18261662f484d2afa84ac7a146#commitcomment-4885242
+    if (Rcpp_IsNaN(right) and Rcpp_IsNA(left)) return true;
+    
+    if (leftNaN != rightNaN) {
+      return leftNaN < rightNaN;
+    } else {
+      return left < right;
+    }
+
+  }
+  
+};
+
+template <>
+struct MapCompare<SEXP> {
+  inline bool operator()(SEXP left, SEXP right) const {
+    return StrCmp(left, right) < 0;
+  }
+};
+
+}
+}
+
+#endif