00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <Rcpp/RObject.h>
00023 #include <algorithm>
00024
00025 namespace Rcpp {
00026
00027 RObject wrap(SEXP m_sexp=R_NilValue){
00028 return RObject(m_sexp) ;
00029 }
00030
00031 RObject wrap(const bool & v){
00032 logTxt("RObject from bool\n");
00033 RObject o(Rf_ScalarLogical(v));
00034 o.preserve() ;
00035 return o ;
00036 }
00037
00038 RObject wrap(const double & v){
00039 logTxt("RObject from double\n");
00040 RObject o(Rf_ScalarReal(v));
00041 o.preserve() ;
00042 return o ;
00043 }
00044
00045 RObject wrap(const int & v){
00046 logTxt("RObject from int\n");
00047 RObject o(Rf_ScalarInteger(v));
00048 o.preserve() ;
00049 return o ;
00050 }
00051
00052 RObject wrap(const Rbyte & v){
00053 logTxt("RObject from raw\n");
00054 RObject o(Rf_ScalarRaw(v));
00055 o.preserve() ;
00056 return o ;
00057 }
00058
00059 RObject wrap(const std::string & v){
00060 logTxt("RObject from std::string\n");
00061 RObject o(Rf_mkString(v.c_str()));
00062 o.preserve() ;
00063 return o ;
00064 }
00065
00066 RObject wrap(const std::vector<bool> & v){
00067 logTxt("RObject from bool vector\n");
00068 int n = v.size();
00069 SEXP m_sexp = PROTECT( Rf_allocVector(LGLSXP, n) );
00070 copy( v.begin(), v.end(), LOGICAL(m_sexp) ) ;
00071 RObject o(m_sexp) ;
00072 o.preserve() ;
00073 UNPROTECT(1) ;
00074 return o ;
00075 }
00076
00077 RObject wrap(const std::vector<int> & v){
00078 logTxt("RObject from int vector\n");
00079 int n = v.size();
00080 SEXP m_sexp = PROTECT( Rf_allocVector(INTSXP, n) );
00081 copy( v.begin(), v.end(), INTEGER(m_sexp) ) ;
00082 RObject o(m_sexp) ;
00083 o.preserve() ;
00084 UNPROTECT(1) ;
00085 return o ;
00086 }
00087
00088 RObject wrap(const std::vector<double> & v){
00089 logTxt("RObject from double vector\n");
00090 int n = v.size();
00091 SEXP m_sexp = PROTECT( Rf_allocVector(REALSXP, n) );
00092 copy( v.begin(), v.end(), REAL(m_sexp) ) ;
00093 RObject o(m_sexp) ;
00094 o.preserve() ;
00095 UNPROTECT(1) ;
00096 return o ;
00097 }
00098
00099 RObject wrap(const std::vector<Rbyte> & v){
00100 logTxt("RObject from vector<Rbyte> \n");
00101 int n = v.size();
00102 SEXP m_sexp = PROTECT(Rf_allocVector(RAWSXP, n));
00103 copy( v.begin(), v.end(), RAW(m_sexp) ) ;
00104 RObject o(m_sexp) ;
00105 o.preserve() ;
00106 UNPROTECT(1) ;
00107 return o ;
00108 }
00109
00110 RObject wrap(const std::vector<std::string> & v){
00111 logTxt("RObject from std::string vector\n");
00112 int n = v.size();
00113 SEXP m_sexp = PROTECT(Rf_allocVector(STRSXP, n));
00114 int i=0;
00115 std::vector<std::string>::const_iterator it = v.begin() ;
00116 while( i<n ){
00117 SET_STRING_ELT(m_sexp, i, Rf_mkChar(it->c_str()));
00118 i++ ;
00119 it++;
00120 }
00121 RObject o(m_sexp) ;
00122 o.preserve() ;
00123 UNPROTECT(1) ;
00124 return o ;
00125 }
00126
00127
00128
00129 RObject wrap(const std::set<int> & v){
00130 logTxt("RObject from set<int>\n");
00131 int n = v.size();
00132 SEXP m_sexp = Rf_allocVector(INTSXP, n);
00133 copy( v.begin(), v.end(), INTEGER(m_sexp) ) ;
00134 RObject o(m_sexp) ;
00135 o.preserve() ;
00136 UNPROTECT(1) ;
00137 return o ;
00138 }
00139
00140 RObject wrap(const std::set<double> & v){
00141 logTxt("RObject from set<double>\n");
00142 int n = v.size();
00143 SEXP m_sexp = Rf_allocVector(REALSXP, n);
00144 copy( v.begin(), v.end(), REAL(m_sexp) ) ;
00145 RObject o(m_sexp) ;
00146 o.preserve() ;
00147 UNPROTECT(1) ;
00148 return o ;
00149 }
00150
00151 RObject wrap(const std::set<Rbyte> & v){
00152 logTxt("RObject from set<Rbyte> \n");
00153 int n = v.size();
00154 SEXP m_sexp = Rf_allocVector(RAWSXP, n);
00155 copy( v.begin(), v.end(), RAW(m_sexp) ) ;
00156 RObject o(m_sexp) ;
00157 o.preserve() ;
00158 UNPROTECT(1) ;
00159 return o ;
00160 }
00161
00162 RObject wrap(const std::set<std::string> & v){
00163 logTxt("RObject from set<string>\n");
00164 int n = v.size();
00165 SEXP m_sexp = Rf_allocVector(STRSXP, n);
00166 int i=0;
00167 std::set<std::string>::iterator it = v.begin();
00168 while( i<n ){
00169 SET_STRING_ELT(m_sexp, i, Rf_mkChar(it->c_str()));
00170 i++ ;
00171 it++;
00172 }
00173 RObject o(m_sexp) ;
00174 o.preserve() ;
00175 UNPROTECT(1) ;
00176 return o ;
00177 }
00178
00179 RObject::~RObject() {
00180 logTxt("~RObject");
00181 release() ;
00182 }
00183
00184 double RObject::asDouble() const {
00185 if (Rf_length(m_sexp) != 1) {
00186 throw std::range_error("RObject::asDouble expects single value");
00187 }
00188 switch( TYPEOF(m_sexp) ){
00189 case LGLSXP:
00190 return LOGICAL(m_sexp)[0] ? 1.0 : 0.0 ;
00191 case REALSXP:
00192 return REAL(m_sexp)[0] ;
00193 case INTSXP:
00194 return (double)INTEGER(m_sexp)[0];
00195 case RAWSXP:
00196 return (double)RAW(m_sexp)[0];
00197 default:
00198 throw std::range_error("RObject::asDouble invalid type");
00199 }
00200 return 0.0 ;
00201 }
00202
00203 int RObject::asInt() const {
00204 if (Rf_length(m_sexp) != 1) {
00205 throw std::range_error("RObject::asInt expects single value");
00206 }
00207 switch( TYPEOF(m_sexp)){
00208 case LGLSXP:
00209 return LOGICAL(m_sexp)[0] ? 1 : 0 ;
00210 case REALSXP:
00211 return (int)REAL(m_sexp)[0] ;
00212 case INTSXP:
00213 return INTEGER(m_sexp)[0];
00214 case RAWSXP:
00215 return (int)RAW(m_sexp)[0];
00216 default:
00217 throw std::range_error("RObject::asInt invalid type");
00218 }
00219 return 0;
00220 }
00221
00222 Rbyte RObject::asRaw() const {
00223 if (Rf_length(m_sexp) != 1) {
00224 throw std::range_error("RObject::asRaw expects single value");
00225 }
00226 switch( TYPEOF(m_sexp) ){
00227 case LGLSXP:
00228 return LOGICAL(m_sexp)[0] ? (Rbyte)1 : (Rbyte)0 ;
00229 case REALSXP:
00230 return (Rbyte)REAL(m_sexp)[0] ;
00231 case INTSXP:
00232 return (Rbyte)INTEGER(m_sexp)[0] ;
00233 case RAWSXP:
00234 return RAW(m_sexp)[0] ;
00235 default:
00236 throw std::range_error("RObject::asRaw expects raw, double or int");
00237 }
00238 return (Rbyte)0;
00239 }
00240
00241 bool RObject::asBool() const {
00242 if (Rf_length(m_sexp) != 1) {
00243 throw std::range_error("RObject::asRaw expects single value");
00244 }
00245 switch( TYPEOF(m_sexp) ){
00246 case LGLSXP:
00247 return LOGICAL(m_sexp)[0] ? true : false ;
00248 case REALSXP:
00249 return (bool)REAL(m_sexp)[0] ;
00250 case INTSXP:
00251 return (bool)INTEGER(m_sexp)[0] ;
00252 case RAWSXP:
00253 return (bool)RAW(m_sexp)[0] ;
00254 default:
00255 throw std::range_error("RObject::asRaw expects raw, double or int");
00256 }
00257 return false;
00258 }
00259
00260 std::string RObject::asStdString() const {
00261 if (Rf_length(m_sexp) != 1) {
00262 throw std::range_error("RObject::asStdString expects single value");
00263 }
00264 if (!Rf_isString(m_sexp)) {
00265 throw std::range_error("RObject::asStdString expects string");
00266 }
00267 return std::string(CHAR(STRING_ELT(m_sexp,0)));
00268 }
00269
00270 std::vector<bool> RObject::asStdVectorBool() const {
00271 int n = Rf_length(m_sexp);
00272 std::vector<bool> v(n);
00273 switch( TYPEOF(m_sexp) ){
00274 case LGLSXP:
00275 v.assign( LOGICAL(m_sexp), LOGICAL(m_sexp)+n ) ;
00276 break ;
00277 case INTSXP:
00278 v.assign( INTEGER(m_sexp), INTEGER(m_sexp)+n ) ;
00279 break;
00280 case REALSXP:
00281 v.assign( REAL(m_sexp), REAL(m_sexp)+n ) ;
00282 break;
00283 case RAWSXP:
00284 v.assign( RAW(m_sexp), RAW(m_sexp)+n ) ;
00285 break;
00286 default:
00287 throw std::range_error( "RObject::asStdVectorBool(): invalid R type" ) ;
00288 }
00289 return v;
00290 }
00291
00292
00293 std::vector<int> RObject::asStdVectorInt() const {
00294 int n = Rf_length(m_sexp);
00295 std::vector<int> v(n);
00296 switch( TYPEOF(m_sexp) ){
00297 case LGLSXP:
00298 v.assign( LOGICAL(m_sexp), LOGICAL(m_sexp)+n ) ;
00299 break;
00300 case INTSXP:
00301 v.assign( INTEGER(m_sexp), INTEGER(m_sexp)+n ) ;
00302 break;
00303 case REALSXP:
00304 v.assign( REAL(m_sexp), REAL(m_sexp)+n ) ;
00305 break;
00306 case RAWSXP:
00307 v.assign( RAW(m_sexp), RAW(m_sexp)+n ) ;
00308 break;
00309 default:
00310 throw std::range_error( "RObject::asStdVectorInt(): invalid R type" ) ;
00311 }
00312 return v;
00313 }
00314
00315 std::vector<Rbyte> RObject::asStdVectorRaw() const {
00316 int n = Rf_length(m_sexp);
00317 std::vector<Rbyte> v(n);
00318 switch( TYPEOF(m_sexp) ){
00319 case LGLSXP:
00320 v.assign( LOGICAL(m_sexp), LOGICAL(m_sexp)+n ) ;
00321 break ;
00322 case RAWSXP:
00323 v.assign( RAW(m_sexp), RAW(m_sexp)+n ) ;
00324 break ;
00325 case REALSXP:
00326 v.assign( REAL(m_sexp), REAL(m_sexp)+n) ;
00327 break;
00328 case INTSXP:
00329 v.assign( INTEGER(m_sexp), INTEGER(m_sexp)+n) ;
00330 break;
00331 default:
00332 throw std::range_error("RObject::asStdVectorRaw expects raw, double or int");
00333 }
00334 return v;
00335 }
00336
00337 std::vector<double> RObject::asStdVectorDouble() const {
00338 int n = Rf_length(m_sexp);
00339 std::vector<double> v(n);
00340 switch( TYPEOF(m_sexp) ){
00341 case LGLSXP:
00342 v.assign( LOGICAL(m_sexp), LOGICAL(m_sexp)+n ) ;
00343 break ;
00344 case RAWSXP:
00345 v.assign( RAW(m_sexp), RAW(m_sexp)+n ) ;
00346 break ;
00347 case REALSXP:
00348 v.assign( REAL(m_sexp), REAL(m_sexp)+n) ;
00349 break;
00350 case INTSXP:
00351 v.assign( INTEGER(m_sexp), INTEGER(m_sexp)+n) ;
00352 break;
00353 default:
00354 throw std::range_error("RObject::asStdVectorDouble expects raw, double or int");
00355 }
00356 return v;
00357 }
00358
00359
00360 std::vector<std::string> RObject::asStdVectorString() const {
00361 int n = Rf_length(m_sexp);
00362 std::vector<std::string> v(n);
00363 if (!Rf_isString(m_sexp)) {
00364 throw std::range_error("RObject::asStdVectorString expects string");
00365 }
00366 for (int i = 0; i < n; i++) {
00367 v[i] = std::string(CHAR(STRING_ELT(m_sexp,i)));
00368 }
00369 return v;
00370 }
00371
00372 void RObject::preserve(){
00373 if( !preserved ){
00374 preserved = true ;
00375 R_PreserveObject( m_sexp );
00376 }
00377 }
00378
00379 void RObject::release(){
00380 if( preserved ){
00381 R_ReleaseObject(m_sexp);
00382 }
00383 }
00384
00385 void RObject::forgetPreserve(){
00386 preserved = false ;
00387 }
00388
00389 std::vector<std::string> RObject::attributeNames() const {
00390
00391
00392 std::vector<std::string> v ;
00393 SEXP attrs = ATTRIB(m_sexp);
00394 while( attrs != R_NilValue ){
00395 v.push_back( std::string(CHAR(PRINTNAME(TAG(attrs)))) ) ;
00396 attrs = CDR( attrs ) ;
00397 }
00398 return v ;
00399 }
00400
00401 bool RObject::hasAttribute( const std::string& attr) const {
00402 SEXP attrs = ATTRIB(m_sexp);
00403 while( attrs != R_NilValue ){
00404 if( attr == CHAR(PRINTNAME(TAG(attrs))) ){
00405 return true ;
00406 }
00407 attrs = CDR( attrs ) ;
00408 }
00409 return false;
00410 }
00411
00412 SEXP RObject::attr( const std::string& name) const{
00413 return Rf_getAttrib( m_sexp, Rf_install( name.c_str() ) );
00414 }
00415
00416
00417 }
00418