Java SEXP类代码示例

import org.renjin.sexp.SEXP; //导入依赖的package包/类
public static SEXP doApply(Context context, Environment environment, SEXP arg0, SEXP arg1)
    throws Exception
{
    if ((arg0 instanceof ListVector)&&((arg1 instanceof Vector)&&StringVector.VECTOR_TYPE.isWiderThanOrEqualTo(((Vector) arg1)))) {
        return Time.asPOSIXct(((ListVector) arg0), WrapperRuntime.convertToString(arg1));
    } else {
        throw new EvalException(String.format("Invalid argument:\n\tas.POSIXct(%s, %s)\n\tExpected:\n\tas.POSIXct(list, character(1))", arg0 .getTypeName(), arg1 .getTypeName()));
    }
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
@Override
public Builder add(SEXP in) {
	if((in instanceof StringVector)) {
		StringVector value = (StringVector)in;			
		String str = value.getElementAsString(0);
		
		int index = levels.indexOf(str);
		if(index == -1) {
			index = levels.size();
			levels.add(str);				
		}
		
		// R indexes start at 1 not 0
		delegate.add(index + 1);			
		return this;
	} else {
		return null;
	}
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
@Override
public Value invValue(QueryContext qc, InputInfo ii, Value... args) throws QueryException {
	RenjinScriptEngine  engine = (RenjinScriptEngine) renjin.getEngine();
	Context ctx = engine.getTopLevelContext();
	
	PairList.Builder arguments = new PairList.Builder();
	for(Value v : args) {
		if(v.size() > 0) {
			arguments.add(XqRenjinModule.xQueryValueToRValue(renjin, v));
		}
	}
	
	FunctionCall call = new FunctionCall(func, arguments.build());	
	SEXP result = ctx.evaluate(call);
	
	return XqRenjinModule.rValueToXQueryValue(renjin, result);
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
/**
   * Converts an R value (SEXP) into a XQuery value (Value)
   * 
   * @param renjin Engine the value exists in.
   * @param in The value to convert
   * @return The converted value for use in XQuery
   */
public static Value rValueToXQueryValue(XqRenjin renjin, SEXP in) {
	Value out = empty.value();
	
	if(in != null) {
		if (in instanceof ListVector) {
			out = processListVectorValue(renjin, (ListVector) in);
		} else if (in instanceof AtomicVector) {
			out = processAtomicVectorValue(renjin, (AtomicVector) in);
		} else if (in instanceof Function) {
			out = processFunctionValue(renjin, (Function) in);
		} else if (in instanceof FunctionCall) {
			out = processFunctionCallValue(renjin, (FunctionCall) in);
		}
	}
	
	return out;
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
@Test
public void testLocals() throws ScriptException {
	final Context context = new Context(ScriptService.class);
	final ScriptService scriptService = context.getService(ScriptService.class);

	final ScriptLanguage language = scriptService.getLanguageByExtension("r");
	final ScriptEngine engine = language.getScriptEngine();
	assertEquals(RenjinScriptEngine.class, engine.getClass());
	engine.put("hello", 17);
	assertEquals(17, RenjinUtils.getJavaValue((SEXP) engine.eval("hello")));
	assertEquals(17, RenjinUtils.getJavaValue((SEXP) engine.get("hello")));

	final Bindings bindings = engine.getBindings(ScriptContext.ENGINE_SCOPE);
	bindings.clear();
	assertNull(RenjinUtils.getJavaValue((SEXP) engine.get("hello")));
	assertNull(RenjinUtils.getJavaValue((SEXP) engine.get("polar_kraken")));
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
private ExpressionVector parseAll() throws IOException {
  List<SEXP> exprList = new ArrayList();

  while (parse()) {
    StatusResult status = getResultStatus();
    switch (status) {
      case EMPTY:
        break;
      case INCOMPLETE:
      case OK:
        exprList.add(getResult());
        break;
      case ERROR:
        throw new ParseException(getResultStatus().toString());
      case EOF:
        return new ExpressionVector( exprList );
    }
  }
  return new ExpressionVector( exprList );
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
public static SEXP doApply(Context context, Environment environment, SEXP arg0, SEXP arg1, SEXP arg2, SEXP arg3)
    throws Exception
{
    if (((((arg0 instanceof Vector)&&StringVector.VECTOR_TYPE.isWiderThanOrEqualTo(((Vector) arg0)))&&(arg1 instanceof SEXP))&&(arg2 instanceof SEXP))&&(arg3 instanceof SEXP)) {
        return Native.dynLoad(WrapperRuntime.convertToString(arg0), ((SEXP) arg1), ((SEXP) arg2), ((SEXP) arg3));
    } else {
        throw new EvalException(String.format("Invalid argument:\n\tdyn.load(%s, %s, %s, %s)\n\tExpected:\n\tdyn.load(character(1), any, any, any)", arg0 .getTypeName(), arg1 .getTypeName(), arg2 .getTypeName(), arg3 .getTypeName()));
    }
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
/**
 * Default implementation of as.function. Note that this is an
 * internal primitive called by the closure "as.function.default" in the
 * base package, so it is not itself generic.
 * 
 * @param list a ListVector containing the formal argument and the last element as the function body
 * @param envir the environment overwhich to close
 * @return a new Closure
 */
@Primitive("as.function.default")
public static Closure asFunctionDefault(ListVector list, Environment envir) {

  PairList.Builder formals = new PairList.Builder();
  for(int i=0;(i+1)<list.length();++i) {
    String name = list.getName(i);
    if(Strings.isNullOrEmpty(name)) {
      throw new EvalException("formal arguments to a closure must be named");
    }
    formals.add(name, list.getElementAsSEXP(i));
  }
  SEXP body = list.getElementAsSEXP(list.length() - 1);
  
  return new Closure(envir, formals.build(), body);
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
@Override
public double getDouble(final String variable) {
    try {
        final SEXP sexp = (SEXP) engine.unwrap().eval(variable);
        return sexp.asReal();
    } catch (final ScriptException e) {
        throw new RuntimeException(e);
    }
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
@Override
public boolean getBoolean(final String variable) {
    try {
        final SEXP sexp = (SEXP) engine.unwrap().eval(variable);
        return sexp.asLogical() == Logical.TRUE;
    } catch (final ScriptException e) {
        throw new RuntimeException(e);
    }
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
@Override
public Value invValue(QueryContext qc, InputInfo ii, Value... args) throws QueryException {
       Value name = args[0];
       SEXP rValue = null;
       int index = vector.getIndexByName((String) name.toJava());
       if(index >= 0) {
       	rValue = vector.getElementAsSEXP(index);
       } else {
       	AttributeMap attrs = vector.getAttributes();
       	if(!(vector instanceof ListVector)) {
       		Vector rows = attrs.getDimNames().getElementAsSEXP(0);
       		Vector columns = attrs.getDimNames().getElementAsSEXP(1);
       		int binSize = vector.length() / columns.length();
       		int colIndex = columns.indexOf(new StringArrayVector(((String)name.toJava())), 0, 0);
       		if(colIndex >= 0) {
       			Builder builder = XqRenjinModule.vectorToBuilder(vector, binSize);
       			for(int i = colIndex * binSize, x = 0; x < binSize; x++, i++) {
       				builder.add(vector.getElementAsSEXP(i));
       			}
       			rValue = builder.build();
       		}
       	} else {
       		rValue = attrs.get((String) name.toJava());
       	}
       }

   	return rValue.length() == 0 ? (new ValueBuilder()).value() : XqRenjinModule.rValueToXQueryValue(renjin, rValue);
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
/**
    * Converts an XQuery value (Value) into an R value (SEXP)
    * 
    * @param renjin Engine the value exists in.
    * @param in The value to convert
    * @return The converted value for use in R
    */
   public static SEXP xQueryValueToRValue(XqRenjin renjin, Value val) throws QueryException {
	// TODO Auto-generated method stub
   	SEXP out = null;
   	
   	if(val instanceof XqRenjinObject) {
   		out = ((XqRenjinObject)val).getVector();
   	} else if(val instanceof Map) {
   		out = processXQueryMap(renjin, (Map)val);
   	} else if(val.size() > 1 && val instanceof Seq && val.itemAt(0) instanceof Map) {
   		out = processXQueryAsDataFrame(renjin, val);
   	} 
   	
   	if(out == null && (val instanceof Array || val instanceof Seq)) {
   		out = processXQueryArray(renjin, val);
   	} else if(out == null && val instanceof FItem) {
   		out = processXQueryFunction(renjin, (FItem)val);
   	}
   	
   	if(out == null) {    		
   		try {
   			Object jValue = val.toJava();
   			if(jValue instanceof BigInteger) {
   				jValue = ((BigInteger)jValue).intValue();
   			}
   			
			out = RuntimeConverter.INSTANCE.convertToR(jValue);
		} catch (QueryException e) {
			throw new QueryException("Failed to convert value to R value: " + val.toString());
		}
   	}
   	
	return out;
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
private static SEXP processXQueryArray(XqRenjin renjin, Value val) throws QueryException {
	SEXP out = null;
	boolean isArray = false;
	if(val instanceof Array) {
		isArray = true;
		if(((Array)val).get(0) instanceof Map) {
			out = processXQueryAsDataFrame(renjin, val);
		}
	}

	Builder builder = xqValueToBuilder(val);
	if(out == null) {
		long size = isArray ? ((Array)val).arraySize() : val.size();
		for(long i = 0; i < size; i++) {
		    Item item = (Item) (isArray ? ((Array)val).get(i) : val.itemAt(i));
			try {
				builder.add(XqRenjinModule.xQueryValueToRValue(renjin, item));
			} catch (QueryException e) {
				throw new QueryException("Failed to process array value: " + item.toString() + ". " + e.getMessage());
			}
		}
		
		out = builder.build();
	}
	
	return out;
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
private static SEXP processXQueryMap(XqRenjin renjin, Map val) throws QueryException {
	Value keys = val.keys();
	NamedBuilder out = ListVector.newNamedBuilder();
	for(Item key : keys) {
		out.add((String)key.toJava(), xQueryValueToRValue(renjin, val.get(key, null)));
	}
	
	return out.build();
}
 

import org.renjin.sexp.SEXP; //导入依赖的package包/类
/**
 * Evaluate all the function calls.
 */
public void prePassCode() {
  SEXP source = RParser.parseSource(this.programText + "\n", "inline-string");
  if (isSameClass(source, ExpressionVector.class)) {
    ExpressionVector ev = (ExpressionVector) source;
    // Stores the expressions except size().
    List<SEXP> sexps = new ArrayList<SEXP>();
    for (int i = ev.length() - 1; i >= 0; --i) {
      if (isSameClass(ev.get(i), FunctionCall.class)
          && isSameClass(((FunctionCall) ev.get(i)).getFunction(), Symbol.class)) {
        if (((Symbol) ((FunctionCall) ev.get(i)).getFunction()).getPrintName().equals("<-")) {
          this.renjinEngine.getTopLevelContext().evaluate(ev.get(i),
              this.renjinEngine.getTopLevelContext().getEnvironment());
          sexps.add(ev.get(i));
        } else if (((Symbol) ((FunctionCall) ev.get(i)).getFunction()).getPrintName()
            .equals(Constant.SIZE_NAME)) {
          // size function is defined in global namespace.
          log("size function is defined in global namespace.");
          hasSize = true;
          sizeFunction = ev.get(i);
        } else {
          sexps.add(ev.get(i));
        }
      }
    }

    expressionVector = new ExpressionVector(sexps);
  }
}