Java SEXP.getAttribute方法代码示例

import org.renjin.sexp.SEXP; //导入方法依赖的package包/类
public static StringVector R_data_class(SEXP obj, boolean singleString) {
  SEXP value;
  SEXP klass = obj.getAttribute(Symbols.CLASS);
  int n = klass.length();
  if(n == 1 || (n > 0 && !singleString))
    return (StringVector) (klass);
  if(n == 0) {
    SEXP dim = obj.getAttribute(Symbols.DIM);
    int nd = dim.length();
    if(nd > 0) {
      if(nd == 2) 
        return StringVector.valueOf("matrix");
      else
        return StringVector.valueOf("array");
    } else {
      if(obj instanceof Function) {
        return StringVector.valueOf("function");
      } else if(obj instanceof DoubleVector) {
        return StringVector.valueOf("numeric");
      } else if(obj instanceof Symbol) {
        return StringVector.valueOf("name");
      }       
    }
  }
  return StringVector.valueOf(obj.getImplicitClass());
}
 

import org.renjin.sexp.SEXP; //导入方法依赖的package包/类
static SEXP R_do_slot(Context context, SEXP obj, SEXP slotName) {
  Symbol name = checkSlotName(slotName);

  if(name == MethodDispatch.s_dot_Data)
    return data_part(context, obj);
  else {
    SEXP value = obj.getAttribute(name);
    if(value == Null.INSTANCE) {
      String input = name.getPrintName();
      SEXP classString;
      if(name == MethodDispatch.s_dot_S3Class) {
        /* defaults to class(obj) */
        //return R_data_class(obj, false);
        throw new UnsupportedOperationException();
      }
      input = name.getPrintName();
      classString = obj.getAttribute(Symbols.CLASS);
      if(classString == Null.INSTANCE) {
        throw new EvalException("cannot get a slot (\"%s\") from an object of type \"%s\"",
            input, obj.getTypeName());
      }

      /* not there.  But since even NULL really does get stored, this
       implies that there is no slot of this name.  Or somebody
       screwed up by using attr(..) <- NULL */

      throw new EvalException("no slot of name \"%s\" for this object of class \"%s\"",
          input, classString.asString());
    }
    else if(value == MethodDispatch.pseudo_NULL) {
      value = Null.INSTANCE;
    }
    return value;
  }
}
 

import org.renjin.sexp.SEXP; //导入方法依赖的package包/类
@Primitive
public static SEXP environment(@Current Context context, SEXP exp) {
  if (exp == Null.INSTANCE) {
    // if the user passes null, we return the current exp
    // but since this primitive is internal, we will be called by a wrapping closure,
    // so grab the parent context      
    return context.getCallingEnvironment();
  } else if (exp instanceof Closure) {
    return ((Closure) exp).getEnclosingEnvironment();
  } else {
    return exp.getAttribute(Symbols.DOT_ENVIRONMENT);
  }
}
 

import org.renjin.sexp.SEXP; //导入方法依赖的package包/类
@Primitive("@")
public static SEXP getSlotValue(@Current Context context, @Current MethodDispatch methods, SEXP object, @Evaluate(false) Symbol slotName) {
  if(slotName.getPrintName().equals(".Data")) {
    return context.evaluate(FunctionCall.newCall(Symbol.get("getDataPart"), object), methods.getMethodsNamespace());
  }
  
  SEXP value = object.getAttribute(slotName);
  if(value == Symbols.S4_NULL) {
    return Null.INSTANCE;
  } else {
    return value;
  }
}
 

import org.renjin.sexp.SEXP; //导入方法依赖的package包/类
/**
 * Computes the class list used for normal S3 Dispatch. Note that this
 * is different than the class() function
 */
public static StringVector computeDataClasses(Context context, SEXP exp) {

  /*
   * Make sure we're dealing with the evaluated expression
   */
  exp = exp.force(context);

  SEXP classAttribute = exp.getAttribute(Symbols.CLASS);

  if(classAttribute.length() > 0) {
    /*
     * S3 Class has been explicitly defined
     */
    return (StringVector)classAttribute;
  } else {
    /*
     * Compute implicit class based on DIM attribute and type
     */
    StringArrayVector.Builder dataClass = new StringArrayVector.Builder();
    SEXP dim = exp.getAttribute(Symbols.DIM);
    if(dim.length() == 2) {
      dataClass.add("matrix");
    } else if(dim.length() == 1) {
      dataClass.add("array");
    }
    if(exp instanceof IntVector || exp instanceof DoubleVector) {
      dataClass.add(exp.getTypeName());
      dataClass.add("numeric");
    } else {
       dataClass.add(exp.getImplicitClass());
    }
    return dataClass.build();
  }
}
 

import org.renjin.sexp.SEXP; //导入方法依赖的package包/类
public static SEXP get_this_generic(Context context, String fname) {
  SEXP value = Null.INSTANCE;

  //    /* a second argument to the call, if any, is taken as the function */
  //    if(args.length() >= 2) {
  //      return args.getElementAsSEXP(1);
  //    }
  /* else use sys.function (this is fairly expensive-- would be good
   * to force a second argument if possible) */

  Context cptr = context;
  int n = cptr.getFrameDepth();
  for(int i=0;i<n;++i) {
    SEXP rval = Contexts.R_sysfunction(i, context);
    if(rval.isObject()) {
      SEXP generic = rval.getAttribute(MethodDispatch.GENERIC);
      if(generic instanceof StringVector && generic.asString().equals(fname)) {
        value = rval;
        break;
      }
    }
  }
  return value;

  //    cptr = R_GlobalContext;
  //    fname = translateChar(asChar(CAR(args)));
  //    n = framedepth(cptr);
  //    /* check for a matching "generic" slot */
  //    for(i=0;  i<n; i++) {
  //      SEXP rval = R_sysfunction(i, cptr);
  //      if(isObject(rval)) {
  //        SEXP generic = getAttrib(rval, gen_name);
  //        if(TYPEOF(generic) == STRSXP &&
  //            !strcmp(translateChar(asChar(generic)), fname)) {
  //          value = rval;
  //          break;
  //        }
  //      }
  //    }
  //    return(value);
}