replace R_len_t with R_xlen_t

Qiang Kou · Qiang Kou · commit 70ad47220d2a · 2015-05-16T17:27:30.000-04:00
diff --git a/inst/include/Rcpp/DottedPairImpl.h b/inst/include/Rcpp/DottedPairImpl.h
@@ -63,11 +63,11 @@ namespace Rcpp{
         template <typename T>
         void replace( const int& index, const T& object ) ;
 
-        inline R_len_t length() const {
+        inline R_xlen_t length() const {
             return ::Rf_length(static_cast<const CLASS&>(*this).get__()) ;
         }
 
-        inline R_len_t size() const {
+        inline R_xlen_t size() const {
             return ::Rf_length(static_cast<const CLASS&>(*this).get__()) ;
         }
 
diff --git a/inst/include/Rcpp/api/meat/DottedPairImpl.h b/inst/include/Rcpp/api/meat/DottedPairImpl.h
@@ -53,7 +53,7 @@ namespace Rcpp{
 		} else {
 			if( ref.isNULL( ) ) throw index_out_of_bounds() ;
 
-			if( static_cast<R_len_t>(index) > ::Rf_length(ref.get__()) ) throw index_out_of_bounds() ;
+                        if( static_cast<R_xlen_t>(index) > ::Rf_length(ref.get__()) ) throw index_out_of_bounds() ;
 
 			size_t i=1;
 			SEXP x = ref.get__() ;
@@ -70,7 +70,7 @@ namespace Rcpp{
     template <typename T>
 	void DottedPairImpl<CLASS>::replace( const int& index, const T& object ) {
 	    CLASS& ref = static_cast<CLASS&>(*this) ;
-        if( static_cast<R_len_t>(index) >= ::Rf_length(ref.get__()) ) throw index_out_of_bounds() ;
+        if( static_cast<R_xlen_t>(index) >= ::Rf_length(ref.get__()) ) throw index_out_of_bounds() ;
 
         Shield<SEXP> x( pairlist( object ) );
         SEXP y = ref.get__() ;
@@ -84,7 +84,7 @@ namespace Rcpp{
 	template <typename CLASS>
     void DottedPairImpl<CLASS>::remove( const size_t& index ) {
         CLASS& ref = static_cast<CLASS&>(*this) ;
-        if( static_cast<R_len_t>(index) >= Rf_length(ref.get__()) ) throw index_out_of_bounds() ;
+        if( static_cast<R_xlen_t>(index) >= Rf_length(ref.get__()) ) throw index_out_of_bounds() ;
         if( index == 0 ){
             ref.set__( CDR( ref.get__() ) ) ;
         } else{
diff --git a/inst/include/Rcpp/api/meat/export.h b/inst/include/Rcpp/api/meat/export.h
@@ -27,8 +27,8 @@ namespace internal{
 
     template <typename InputIterator, typename value_type>
     void export_range__dispatch( SEXP x, InputIterator first, ::Rcpp::traits::r_type_generic_tag ) {
-        R_len_t n = ::Rf_length(x) ;
-        for( R_len_t i=0; i<n; i++, ++first ){
+        R_xlen_t n = ::Rf_length(x) ;
+        for( R_xlen_t i=0; i<n; i++, ++first ){
             *first = ::Rcpp::as<value_type>( VECTOR_ELT(x, i) ) ;
         }
     }
diff --git a/inst/include/Rcpp/internal/export.h b/inst/include/Rcpp/internal/export.h
@@ -28,19 +28,19 @@ namespace Rcpp{
 
 
 		template <typename T>
-		std::wstring as_string_elt__impl( SEXP x, R_len_t i, Rcpp::traits::true_type ){
+		std::wstring as_string_elt__impl( SEXP x, R_xlen_t i, Rcpp::traits::true_type ){
 			const char* y = char_get_string_elt( x, i ) ;
 			return std::wstring(y, y+strlen(y) ) ;
 		}
 
 		template <typename T>
-		std::string as_string_elt__impl( SEXP x, R_len_t i, Rcpp::traits::false_type ){
+		std::string as_string_elt__impl( SEXP x, R_xlen_t i, Rcpp::traits::false_type ){
 			return char_get_string_elt( x, i ) ;
 		}
 
 		template <typename T>
 		const std::basic_string< typename Rcpp::traits::char_type<T>::type >
-		as_string_elt( SEXP x, R_len_t i ){
+		as_string_elt( SEXP x, R_xlen_t i ){
 			return as_string_elt__impl<T>( x, i, typename Rcpp::traits::is_wide_string<T>::type() ) ;
 		}
 
@@ -80,8 +80,8 @@ namespace Rcpp{
 		template <typename InputIterator, typename value_type>
 		void export_range__dispatch( SEXP x, InputIterator first, ::Rcpp::traits::r_type_string_tag ) {
 			if( ! ::Rf_isString( x) ) throw ::Rcpp::not_compatible( "expecting a string vector" ) ;
-			R_len_t n = ::Rf_length(x) ;
-			for( R_len_t i=0; i<n; i++, ++first ){
+			R_xlen_t n = ::Rf_length(x) ;
+			for( R_xlen_t i=0; i<n; i++, ++first ){
 				*first = as_string_elt<typename std::iterator_traits<InputIterator>::value_type> ( x, i ) ;
 			}
 		}
@@ -104,8 +104,8 @@ namespace Rcpp{
 			typedef typename ::Rcpp::traits::storage_type<RTYPE>::type STORAGE ;
 			Shield<SEXP> y( ::Rcpp::r_cast<RTYPE>(x) ) ;
 			STORAGE* start = ::Rcpp::internal::r_vector_start<RTYPE>(y) ;
-			R_len_t size = ::Rf_length(y)  ;
-			for( R_len_t i=0; i<size; i++){
+			R_xlen_t size = ::Rf_length(y)  ;
+			for( R_xlen_t i=0; i<size; i++){
 				res[i] =  start[i] ;
 			}
 		}
@@ -116,8 +116,8 @@ namespace Rcpp{
 			typedef typename ::Rcpp::traits::storage_type<RTYPE>::type STORAGE ;
 			Shield<SEXP> y( ::Rcpp::r_cast<RTYPE>(x) );
 			STORAGE* start = ::Rcpp::internal::r_vector_start<RTYPE>(y) ;
-			R_len_t size = ::Rf_length(y)  ;
-			for( R_len_t i=0; i<size; i++){
+			R_xlen_t size = ::Rf_length(y)  ;
+			for( R_xlen_t i=0; i<size; i++){
 				res[i] = caster<STORAGE,value_type>(start[i]) ;
 			}
 		}
@@ -134,8 +134,8 @@ namespace Rcpp{
 		template <typename T, typename value_type>
 		void export_indexing__dispatch( SEXP x, T& res, ::Rcpp::traits::r_type_string_tag ) {
 			if( ! ::Rf_isString( x) ) throw Rcpp::not_compatible( "expecting a string vector" ) ;
-			R_len_t n = ::Rf_length(x) ;
-			for( R_len_t i=0; i<n; i++ ){
+			R_xlen_t n = ::Rf_length(x) ;
+			for( R_xlen_t i=0; i<n; i++ ){
 				res[i] = as_string_elt< value_type >( x, i) ;
 			}
 		}
diff --git a/inst/include/Rcpp/vector/ListOf.h b/inst/include/Rcpp/vector/ListOf.h
@@ -95,7 +95,7 @@ class ListOf
         return list.end();
     }
 
-    inline R_len_t size() const {
+    inline R_xlen_t size() const {
         return list.size() ;
     }
 
diff --git a/inst/include/Rcpp/vector/MatrixBase.h b/inst/include/Rcpp/vector/MatrixBase.h
@@ -43,9 +43,9 @@ namespace Rcpp{
             return static_cast<const MATRIX*>(this)->operator()(i, j) ;
         }
 
-        inline R_len_t size() const { return static_cast<const MATRIX&>(*this).size() ; }
-        inline R_len_t nrow() const { return static_cast<const MATRIX&>(*this).nrow() ; }
-        inline R_len_t ncol() const { return static_cast<const MATRIX&>(*this).ncol() ; }
+        inline R_xlen_t size() const { return static_cast<const MATRIX&>(*this).size() ; }
+        inline R_xlen_t nrow() const { return static_cast<const MATRIX&>(*this).nrow() ; }
+        inline R_xlen_t ncol() const { return static_cast<const MATRIX&>(*this).ncol() ; }
 
         class iterator {
         public:
diff --git a/inst/include/Rcpp/vector/MatrixColumn.h b/inst/include/Rcpp/vector/MatrixColumn.h
@@ -92,12 +92,12 @@ class MatrixColumn : public VectorBase<RTYPE,true,MatrixColumn<RTYPE> > {
         return const_start + n ;
     }
 
-    inline R_len_t size() const {
+    inline R_xlen_t size() const {
         return n ;
     }
 
 private:
-    const R_len_t n ;
+    const R_xlen_t n ;
     iterator start ;
     const_iterator const_start ;
 
diff --git a/inst/include/Rcpp/vector/Vector.h b/inst/include/Rcpp/vector/Vector.h
@@ -237,14 +237,14 @@ class Vector :
     /**
      * the length of the vector, uses Rf_length
      */
-    inline R_len_t length() const {
+    inline R_xlen_t length() const {
         return ::Rf_length( Storage::get__() ) ;
     }
 
     /**
      * alias of length
      */
-    inline R_len_t size() const {
+    inline R_xlen_t size() const {
         return ::Rf_length( Storage::get__() ) ;
     }
 
@@ -267,15 +267,15 @@ class Vector :
      * it is valid
      */
     size_t offset(const size_t& i) const {
-        if( static_cast<R_len_t>(i) >= ::Rf_length(Storage::get__()) ) throw index_out_of_bounds() ;
+        if( static_cast<R_xlen_t>(i) >= ::Rf_length(Storage::get__()) ) throw index_out_of_bounds() ;
         return i ;
     }
 
-    R_len_t offset(const std::string& name) const {
+    R_xlen_t offset(const std::string& name) const {
         SEXP names = RCPP_GET_NAMES( Storage::get__() ) ;
         if( Rf_isNull(names) ) throw index_out_of_bounds();
-        R_len_t n=size() ;
-        for( R_len_t i=0; i<n; ++i){
+        R_xlen_t n=size() ;
+        for( R_xlen_t i=0; i<n; ++i){
             if( ! name.compare( CHAR(STRING_ELT(names, i)) ) ){
                 return i ;
             }

Original file line number	Diff line number	Diff line change
`@@ -63,11 +63,11 @@ namespace Rcpp{`
`63`	`63`	`template <typename T>`
`64`	`64`	`void replace( const int& index, const T& object ) ;`
`65`	`65`
`66`		`- inline R_len_t length() const {`
	`66`	`+ inline R_xlen_t length() const {`
`67`	`67`	`return ::Rf_length(static_cast<const CLASS&>(*this).get__()) ;`
`68`	`68`	`}`
`69`	`69`
`70`		`- inline R_len_t size() const {`
	`70`	`+ inline R_xlen_t size() const {`
`71`	`71`	`return ::Rf_length(static_cast<const CLASS&>(*this).get__()) ;`
`72`	`72`	`}`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@ namespace internal{`
`27`	`27`
`28`	`28`	`template <typename InputIterator, typename value_type>`
`29`	`29`	`void export_range__dispatch( SEXP x, InputIterator first, ::Rcpp::traits::r_type_generic_tag ) {`
`30`		`- R_len_t n = ::Rf_length(x) ;`
`31`		`- for( R_len_t i=0; i<n; i++, ++first ){`
	`30`	`+ R_xlen_t n = ::Rf_length(x) ;`
	`31`	`+ for( R_xlen_t i=0; i<n; i++, ++first ){`
`32`	`32`	`*first = ::Rcpp::as<value_type>( VECTOR_ELT(x, i) ) ;`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,19 +28,19 @@ namespace Rcpp{`
`28`	`28`
`29`	`29`
`30`	`30`	`template <typename T>`
`31`		`- std::wstring as_string_elt__impl( SEXP x, R_len_t i, Rcpp::traits::true_type ){`
	`31`	`+ std::wstring as_string_elt__impl( SEXP x, R_xlen_t i, Rcpp::traits::true_type ){`
`32`	`32`	`const char* y = char_get_string_elt( x, i ) ;`
`33`	`33`	`return std::wstring(y, y+strlen(y) ) ;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`template <typename T>`
`37`		`- std::string as_string_elt__impl( SEXP x, R_len_t i, Rcpp::traits::false_type ){`
	`37`	`+ std::string as_string_elt__impl( SEXP x, R_xlen_t i, Rcpp::traits::false_type ){`
`38`	`38`	`return char_get_string_elt( x, i ) ;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`template <typename T>`
`42`	`42`	`const std::basic_string< typename Rcpp::traits::char_type<T>::type >`
`43`		`- as_string_elt( SEXP x, R_len_t i ){`
	`43`	`+ as_string_elt( SEXP x, R_xlen_t i ){`
`44`	`44`	`return as_string_elt__impl<T>( x, i, typename Rcpp::traits::is_wide_string<T>::type() ) ;`
`45`	`45`	`}`
`46`	`46`
`@@ -80,8 +80,8 @@ namespace Rcpp{`
`80`	`80`	`template <typename InputIterator, typename value_type>`
`81`	`81`	`void export_range__dispatch( SEXP x, InputIterator first, ::Rcpp::traits::r_type_string_tag ) {`
`82`	`82`	`if( ! ::Rf_isString( x) ) throw ::Rcpp::not_compatible( "expecting a string vector" ) ;`
`83`		`- R_len_t n = ::Rf_length(x) ;`
`84`		`- for( R_len_t i=0; i<n; i++, ++first ){`
	`83`	`+ R_xlen_t n = ::Rf_length(x) ;`
	`84`	`+ for( R_xlen_t i=0; i<n; i++, ++first ){`
`85`	`85`	`*first = as_string_elt<typename std::iterator_traits<InputIterator>::value_type> ( x, i ) ;`
`86`	`86`	`}`
`87`	`87`	`}`
`@@ -104,8 +104,8 @@ namespace Rcpp{`
`104`	`104`	`typedef typename ::Rcpp::traits::storage_type<RTYPE>::type STORAGE ;`
`105`	`105`	`Shield<SEXP> y( ::Rcpp::r_cast<RTYPE>(x) ) ;`
`106`	`106`	`STORAGE* start = ::Rcpp::internal::r_vector_start<RTYPE>(y) ;`
`107`		`- R_len_t size = ::Rf_length(y) ;`
`108`		`- for( R_len_t i=0; i<size; i++){`
	`107`	`+ R_xlen_t size = ::Rf_length(y) ;`
	`108`	`+ for( R_xlen_t i=0; i<size; i++){`
`109`	`109`	`res[i] = start[i] ;`
`110`	`110`	`}`
`111`	`111`	`}`
`@@ -116,8 +116,8 @@ namespace Rcpp{`
`116`	`116`	`typedef typename ::Rcpp::traits::storage_type<RTYPE>::type STORAGE ;`
`117`	`117`	`Shield<SEXP> y( ::Rcpp::r_cast<RTYPE>(x) );`
`118`	`118`	`STORAGE* start = ::Rcpp::internal::r_vector_start<RTYPE>(y) ;`
`119`		`- R_len_t size = ::Rf_length(y) ;`
`120`		`- for( R_len_t i=0; i<size; i++){`
	`119`	`+ R_xlen_t size = ::Rf_length(y) ;`
	`120`	`+ for( R_xlen_t i=0; i<size; i++){`
`121`	`121`	`res[i] = caster<STORAGE,value_type>(start[i]) ;`
`122`	`122`	`}`
`123`	`123`	`}`
`@@ -134,8 +134,8 @@ namespace Rcpp{`
`134`	`134`	`template <typename T, typename value_type>`
`135`	`135`	`void export_indexing__dispatch( SEXP x, T& res, ::Rcpp::traits::r_type_string_tag ) {`
`136`	`136`	`if( ! ::Rf_isString( x) ) throw Rcpp::not_compatible( "expecting a string vector" ) ;`
`137`		`- R_len_t n = ::Rf_length(x) ;`
`138`		`- for( R_len_t i=0; i<n; i++ ){`
	`137`	`+ R_xlen_t n = ::Rf_length(x) ;`
	`138`	`+ for( R_xlen_t i=0; i<n; i++ ){`
`139`	`139`	`res[i] = as_string_elt< value_type >( x, i) ;`
`140`	`140`	`}`
`141`	`141`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ class ListOf`
`95`	`95`	`return list.end();`
`96`	`96`	`}`
`97`	`97`
`98`		`- inline R_len_t size() const {`
	`98`	`+ inline R_xlen_t size() const {`
`99`	`99`	`return list.size() ;`
`100`	`100`	`}`
`101`	`101`
Original file line number	Diff line number	Diff line change
`@@ -92,12 +92,12 @@ class MatrixColumn : public VectorBase<RTYPE,true,MatrixColumn<RTYPE> > {`
`92`	`92`	`return const_start + n ;`
`93`	`93`	`}`
`94`	`94`
`95`		`- inline R_len_t size() const {`
	`95`	`+ inline R_xlen_t size() const {`
`96`	`96`	`return n ;`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`private:`
`100`		`- const R_len_t n ;`
	`100`	`+ const R_xlen_t n ;`
`101`	`101`	`iterator start ;`
`102`	`102`	`const_iterator const_start ;`
`103`	`103`