more StoragePolicy use

Author: romainfrancois

inst/include/Rcpp/internal/Proxy_Iterator.h

@@ -81,7 +81,7 @@ class Proxy_Iterator {
 		}
 
 		inline reference operator*() {
-			return proxy ;
+		    return proxy ;
 		}
 		inline pointer operator->(){
 			return &proxy ;

inst/include/Rcpp/vector/Vector.h

@@ -936,6 +936,7 @@ class Vector :
         }
 
         R_xlen_t n = size() ;
+
         Vector target( n - 1 ) ;
         iterator target_it(target.begin()) ;
         iterator it(begin()) ;

inst/include/Rcpp/vector/generic_proxy.h

@@ -31,17 +31,26 @@ namespace internal{
 			generic_proxy(): parent(0), index(-1){}
 
 			generic_proxy( const generic_proxy& other ) :
-				parent(other.parent), index(other.index){} ;
+				parent(other.parent), index(other.index)
+			{}
 
-			generic_proxy( VECTOR& v, R_xlen_t i ) : parent(&v), index(i){} ;
+			generic_proxy( VECTOR& v, R_xlen_t i ) :
+			    parent(&v), index(i)
+			{}
 
 			generic_proxy& operator=(SEXP rhs) {
 				set(rhs) ;
 				return *this ;
 			}
 
-			generic_proxy& operator=(const generic_proxy& rhs) {
-				set(rhs.get());
+			generic_proxy& operator=(const generic_proxy& rhs){
+			    set(rhs.get());
+    		    return *this ;
+			}
+
+			template <template <class> class StoragePolicy2>
+			generic_proxy& operator=(const generic_proxy<RTYPE,StoragePolicy2>& rhs) {
+			    set(rhs.get());
 				return *this ;
 			}
 
@@ -78,13 +87,15 @@ namespace internal{
 				index  = other.index ;
 			}
 
+			inline SEXP get() const {
+			    return VECTOR_ELT(*parent, index );
+			}
+
 		private:
 			inline void set(SEXP x) {
 			    SET_VECTOR_ELT( *parent, index, x ) ;
 			}
-			inline SEXP get() const {
-			    return VECTOR_ELT(*parent, index );
-			}
+
 
 	}  ;
 

inst/include/Rcpp/vector/proxy.h

@@ -222,11 +222,11 @@ namespace traits {
 	} ;
 	template<template <class> class StoragePolicy>
 	struct r_vector_proxy<EXPRSXP, StoragePolicy> {
-		typedef ::Rcpp::internal::generic_proxy<EXPRSXP> type ;
+		typedef ::Rcpp::internal::generic_proxy<EXPRSXP, StoragePolicy> type ;
 	} ;
 	template<template <class> class StoragePolicy>
 	struct r_vector_proxy<VECSXP, StoragePolicy> {
-		typedef ::Rcpp::internal::generic_proxy<VECSXP> type ;
+		typedef ::Rcpp::internal::generic_proxy<VECSXP, StoragePolicy> type ;
 	} ;
 
 	template <int RTYPE, template <class> class StoragePolicy>

inst/include/Rcpp/vector/string_proxy.h

@@ -53,9 +53,10 @@ namespace internal{
 		 *
 		 * @param rhs another proxy, possibly from another vector
 		 */
-		string_proxy& operator=(const string_proxy& other){
-			set( other.get() ) ;
-			return *this ;
+		template <template <class> class StoragePolicy2>
+		string_proxy& operator=( const string_proxy<RTYPE, StoragePolicy2>& other) {
+		    set( other.get() ) ;
+		    return *this ;
 		}
 
 		template <template <class> class StoragePolicy2>

inst/include/Rcpp/vector/traits.h

@@ -55,8 +55,8 @@ namespace traits{
 	class proxy_cache{
 	public:
 		typedef typename ::Rcpp::Vector<RTYPE, StoragePolicy> VECTOR ;
-		typedef typename r_vector_iterator<RTYPE>::type iterator ;
-		typedef typename r_vector_const_iterator<RTYPE>::type const_iterator ;
+		typedef typename r_vector_iterator<RTYPE, StoragePolicy>::type iterator ;
+		typedef typename r_vector_const_iterator<RTYPE, StoragePolicy>::type const_iterator ;
 		typedef typename r_vector_proxy<RTYPE, StoragePolicy>::type proxy ;
 		typedef typename r_vector_const_proxy<RTYPE, StoragePolicy>::type const_proxy ;
 
@@ -75,8 +75,8 @@ namespace traits{
 		inline const_proxy ref() const { return const_proxy(*p,0) ; }
 		inline const_proxy ref(R_xlen_t i) const { return const_proxy(*p,i);}
 
-		private:
-			VECTOR* p ;
+	private:
+		VECTOR* p ;
 	} ;
 
 	// regular types for INTSXP, REALSXP, ...