[Rcpp-commits] r1641 - pkg/Rcpp/inst/include/Rcpp/sugar

[noreply at r-forge.r-project.org]

Author: romain
Date: 2010-06-21 14:40:15 +0200 (Mon, 21 Jun 2010)
New Revision: 1641

Added:
   pkg/Rcpp/inst/include/Rcpp/sugar/logical/
Modified:
   pkg/Rcpp/inst/include/Rcpp/sugar/SingleLogicalResult.h
   pkg/Rcpp/inst/include/Rcpp/sugar/sugar_forward.h
Log:
added ! and && for SingleLogicalResult

Modified: pkg/Rcpp/inst/include/Rcpp/sugar/SingleLogicalResult.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/sugar/SingleLogicalResult.h	2010-06-20 08:04:03 UTC (rev 1640)
+++ pkg/Rcpp/inst/include/Rcpp/sugar/SingleLogicalResult.h	2010-06-21 12:40:15 UTC (rev 1641)
@@ -38,7 +38,6 @@
 		void touch(){}
 }; 
 
-
 template <bool NA,typename T>
 class SingleLogicalResult {
 public:
@@ -80,10 +79,13 @@
 	
 	inline int size(){ return 1 ; }
 	
-private:
-	int result ;
+	inline int get(){
+		apply();
+		return result;
+	}
 	
 protected:
+	int result ;
 	inline void set(int x){ result = x ;}
 	inline void reset(){ set(UNRESOLVED) ; }
 	inline void set_true(){ set(TRUE); }
@@ -92,7 +94,192 @@
 	inline bool is_unresolved(){ return result == UNRESOLVED ; }
 } ;
 
+template <bool NA> struct negate{
+	static inline int apply( int x ){
+		return Rcpp::traits::is_na<LGLSXP>( x ) ? x : 
+			( x ? FALSE : TRUE ) ;
+	}
+} ;
+template<> struct negate<false>{
+	static inline int apply( int x){
+		return x ? FALSE : TRUE ;
+	} ;
+} ;
+
+
+template <bool NA, typename T>
+class Negate_SingleLogicalResult : public SingleLogicalResult<NA, Negate_SingleLogicalResult<NA,T> >{
+public:
+	typedef SingleLogicalResult<NA,T> TYPE ;
+	typedef SingleLogicalResult<NA, Negate_SingleLogicalResult<NA,T> > BASE ;
+	Negate_SingleLogicalResult( const TYPE& orig_ ) : orig(orig_) {}
+	
+	inline void apply(){
+		BASE::set( negate<NA>::apply( orig.get() ) );
+	}
+	
+private:
+	const TYPE& orig ;
+	
+} ;
+
+template <bool LHS_NA, typename LHS_T, bool RHS_NA, typename RHS_T>
+class And_SingleLogicalResult_SingleLogicalResult : 
+public SingleLogicalResult< 
+	(LHS_NA || RHS_NA) , 
+	And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,RHS_NA,RHS_T>
+	>
+{
+public: 
+	typedef SingleLogicalResult<LHS_NA,LHS_T> LHS_TYPE ;
+	typedef SingleLogicalResult<RHS_NA,RHS_T> RHS_TYPE ;
+	typedef SingleLogicalResult< 
+		(LHS_NA || RHS_NA) , 
+		And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,RHS_NA,RHS_T>
+	> BASE ;
+	
+	And_SingleLogicalResult_SingleLogicalResult( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_) :
+		lhs(lhs_), rhs(rhs_){} ;
+	
+	inline void apply(){
+		int left = lhs.get() ;
+		if( Rcpp::traits::is_na<LGLSXP>( left ) ){
+			BASE::set( left ) ;
+		} else if( left == FALSE ){
+			BASE::set( FALSE ) ;
+		} else {
+			BASE::set( rhs.get() ) ;
+		}
+	}
+		
+private:
+	const LHS_TYPE& lhs ;
+	const RHS_TYPE& rhs ;
+	
+} ;
+
+// special version when we know the rhs is not NA     
+template <bool LHS_NA, typename LHS_T, typename RHS_T>
+class And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,false,RHS_T> : 
+public SingleLogicalResult< 
+	LHS_NA , 
+	And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,false,RHS_T>
+	>
+{
+public: 
+	typedef SingleLogicalResult<LHS_NA,LHS_T> LHS_TYPE ;
+	typedef SingleLogicalResult<false,RHS_T> RHS_TYPE ;
+	typedef SingleLogicalResult< 
+		LHS_NA, 
+		And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,false,RHS_T>
+	> BASE ;
+	
+	And_SingleLogicalResult_SingleLogicalResult( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_) :
+		lhs(lhs_), rhs(rhs_){} ;
+	
+	inline void apply(){
+		// here we know rhs does not have NA, so we start with the rhs
+		int right = rhs.get() ;
+		if( right == FALSE ){
+			BASE::set( FALSE ) ;
+		} else {
+			BASE::set( lhs.get() ) ;
+		}
+	}
+		
+private:
+	const LHS_TYPE& lhs ;
+	const RHS_TYPE& rhs ;
+	
+} ;
+
+
+// special version when we know the lhs is not NA     
+template <typename LHS_T, bool RHS_NA, typename RHS_T>
+class And_SingleLogicalResult_SingleLogicalResult<false,LHS_T,RHS_NA,RHS_T> : 
+public SingleLogicalResult< 
+	RHS_NA , 
+	And_SingleLogicalResult_SingleLogicalResult<false,LHS_T,RHS_NA,RHS_T>
+	>
+{
+public: 
+	typedef SingleLogicalResult<false,LHS_T> LHS_TYPE ;
+	typedef SingleLogicalResult<RHS_NA,RHS_T> RHS_TYPE ;
+	typedef SingleLogicalResult< 
+		RHS_NA, 
+		And_SingleLogicalResult_SingleLogicalResult<false,LHS_T,RHS_NA,RHS_T>
+	> BASE ;
+	
+	And_SingleLogicalResult_SingleLogicalResult( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_) :
+		lhs(lhs_), rhs(rhs_){} ;
+	
+	inline void apply(){
+		// here we know lhs does not have NA, so we start with the rhs
+		int left = lhs.get() ;
+		if( left == FALSE ){
+			BASE::set( FALSE ) ;
+		} else {
+			BASE::set( rhs.get() ) ;
+		}
+	}
+		
+private:
+	const LHS_TYPE& lhs ;
+	const RHS_TYPE& rhs ;
+	
+} ;
+
+// special version when we know both the lhs and the rhs are not NA     
+template <typename LHS_T, typename RHS_T>
+class And_SingleLogicalResult_SingleLogicalResult<false,LHS_T,false,RHS_T> : 
+public SingleLogicalResult< 
+	false , 
+	And_SingleLogicalResult_SingleLogicalResult<false,LHS_T,false,RHS_T>
+	>
+{
+public: 
+	typedef SingleLogicalResult<false,LHS_T> LHS_TYPE ;
+	typedef SingleLogicalResult<false,RHS_T> RHS_TYPE ;
+	typedef SingleLogicalResult< 
+		false, 
+		And_SingleLogicalResult_SingleLogicalResult<false,LHS_T,false,RHS_T>
+	> BASE ;
+	
+	And_SingleLogicalResult_SingleLogicalResult( const LHS_TYPE& lhs_, const RHS_TYPE& rhs_) :
+		lhs(lhs_), rhs(rhs_){} ;
+	
+	inline void apply(){
+		int left = lhs.get() ;
+		if( left == FALSE ){
+			BASE::set( FALSE ) ;
+		} else {
+			BASE::set( rhs.get() ) ;
+		}
+	}
+		
+private:
+	const LHS_TYPE& lhs ;
+	const RHS_TYPE& rhs ;
+	
+} ;
+
 }
 }
 
+template <bool NA,typename T>
+inline Rcpp::sugar::Negate_SingleLogicalResult<NA,T> 
+operator!( const Rcpp::sugar::SingleLogicalResult<NA,T>& x){
+	return Rcpp::sugar::Negate_SingleLogicalResult<NA,T>( x );
+}
+
+template <bool LHS_NA, typename LHS_T, bool RHS_NA, typename RHS_T>
+inline Rcpp::sugar::And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,RHS_NA,RHS_T>
+operator&&( 
+	const Rcpp::sugar::SingleLogicalResult<LHS_NA,LHS_T>& lhs, 
+	const Rcpp::sugar::SingleLogicalResult<LHS_NA,LHS_T>& rhs
+){
+	return Rcpp::sugar::And_SingleLogicalResult_SingleLogicalResult<LHS_NA,LHS_T,RHS_NA,RHS_T>( lhs, rhs ) ;
+}
+
+
 #endif

Modified: pkg/Rcpp/inst/include/Rcpp/sugar/sugar_forward.h
===================================================================
--- pkg/Rcpp/inst/include/Rcpp/sugar/sugar_forward.h	2010-06-20 08:04:03 UTC (rev 1640)
+++ pkg/Rcpp/inst/include/Rcpp/sugar/sugar_forward.h	2010-06-21 12:40:15 UTC (rev 1641)
@@ -27,6 +27,6 @@
 #include <Rcpp/sugar/can_have_na.h>
 
 // abstractions
-#include <Rcpp/sugar/SingleLogicalResult.h>
+#include <Rcpp/sugar/logical/SingleLogicalResult.h>
 
 #endif