@Override public Value lazyArrayChunk(final Key key) { final Key arykey = ValueArray.getArrayKey(key); // From the base file key final long off = (_iceRoot != null) ? 0 : ValueArray.getChunkOffset(key); // The offset final Path p = (_iceRoot != null) ? new Path(_iceRoot, getIceName(key, (byte) 'V')) : new Path(arykey.toString()); final Size sz = new Size(); run( new Callable() { @Override public Object call() throws Exception { FileSystem fs = FileSystem.get(p.toUri(), CONF); long rem = fs.getFileStatus(p).getLen() - off; sz._value = (rem > ValueArray.CHUNK_SZ * 2) ? (int) ValueArray.CHUNK_SZ : (int) rem; return null; } }, true, 0); Value val = new Value(key, sz._value, Value.HDFS); val.setdsk(); // But its already on disk. return val; }
/** * Test sending of HTTP GET requests. * * @throws Exception exception */ @Test public void postGet() throws Exception { // GET1 - just send a GET request try (final QueryProcessor qp = new QueryProcessor( _HTTP_SEND_REQUEST.args("<http:request method='get' href='" + REST_ROOT + "'/>"), ctx)) { final Value v = qp.value(); checkResponse(v, 2, HttpURLConnection.HTTP_OK); assertEquals(NodeType.DOC, v.itemAt(1).type); } // GET2 - with override-media-type='text/plain' try (final QueryProcessor qp = new QueryProcessor( _HTTP_SEND_REQUEST.args( "<http:request method='get' override-media-type='text/plain'/>", REST_ROOT), ctx)) { final Value v = qp.value(); checkResponse(v, 2, HttpURLConnection.HTTP_OK); assertEquals(AtomType.STR, v.itemAt(1).type); } // Get3 - with status-only='true' try (final QueryProcessor qp = new QueryProcessor( _HTTP_SEND_REQUEST.args("<http:request method='get' status-only='true'/>", REST_ROOT), ctx)) { checkResponse(qp.value(), 1, HttpURLConnection.HTTP_OK); } }
public static void main(String[] args) { // create a graph with type inferencing SimpleSesameGraph g = new SimpleSesameGraph(true); // //load the film schema and the example data // g.addFile("../roadstead_ontologies/film-ontology.owl", SimpleSesameGraph.RDFXML); // try loading the geopolitical ontology g.addURI("http://aims.fao.org/aos/geopolitical.owl"); // List<HashMap<Object, Value>> solutions = g.runSPARQL("SELECT ?who WHERE { " + // "?who <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> // <http://roadstead.org/film#Person> ." + // "}"); /* Here we are looking for the names of all the things with a name */ List<HashMap<Object, Value>> solutions = g.runSPARQL( "SELECT ?name WHERE { " + "?what <http://aims.fao.org/aos/geopolitical.owl#territory> ?name ." + "?what <http://aims.fao.org/aos/geopolitical.owl#nameListEN> ?name ." + "}"); for (HashMap<Object, Value> object : solutions) { for (Value value : object.values()) { System.out.println("country: " + value.stringValue()); } } }
@Override public List<FeedValue> getFeed(final int count, final String relationshipEntityKey) throws NimbitsException { final User loggedInUser = getUser(); final User feedUser = getFeedUser(relationshipEntityKey, loggedInUser); if (feedUser != null) { final Point point = getFeedPoint(feedUser); if (point == null) { return new ArrayList<FeedValue>(0); } else { final List<Value> values = RecordedValueServiceFactory.getInstance().getTopDataSeries(point, count, new Date()); final List<FeedValue> retObj = new ArrayList<FeedValue>(values.size()); for (final Value v : values) { if (!Utils.isEmptyString(v.getData())) { try { retObj.add(GsonFactory.getInstance().fromJson(v.getData(), FeedValueModel.class)); } catch (JsonSyntaxException ignored) { } } } return retObj; } } else { return new ArrayList<FeedValue>(0); } }
public void exceptionEvent(ExceptionEvent event) { ObjectReference or = event.exception(); ReferenceType rt = or.referenceType(); String exceptionName = rt.name(); // Field messageField = Throwable.class.getField("detailMessage"); Field messageField = rt.fieldByName("detailMessage"); // System.out.println("field " + messageField); Value messageValue = or.getValue(messageField); // System.out.println("mess val " + messageValue); // "java.lang.ArrayIndexOutOfBoundsException" int last = exceptionName.lastIndexOf('.'); String message = exceptionName.substring(last + 1); if (messageValue != null) { String messageStr = messageValue.toString(); if (messageStr.startsWith("\"")) { messageStr = messageStr.substring(1, messageStr.length() - 1); } message += ": " + messageStr; } // System.out.println("mess type " + messageValue.type()); // StringReference messageReference = (StringReference) messageValue.type(); // First just report the exception and its placement reportException(message, or, event.thread()); // Then try to pretty it up with a better message handleCommonErrors(exceptionName, message, listener); if (editor != null) { editor.deactivateRun(); } }
private void printVar(OutputSink out, LocalVariable var, StackFrame frame) { out.print(" " + var.name()); if (var.isVisible(frame)) { Value val = frame.getValue(var); out.println(" = " + val.toString()); } else { out.println(" is not in scope"); } }
/** * Checks the response to an HTTP request. * * @param v query result * @param itemsCount expected number of items * @param expStatus expected status */ private static void checkResponse(final Value v, final int itemsCount, final int expStatus) { assertEquals(itemsCount, v.size()); assertTrue(v.itemAt(0) instanceof FElem); final FElem response = (FElem) v.itemAt(0); assertNotNull(response.attributes()); if (!eq(response.attribute(STATUS), token(expStatus))) { fail("Expected: " + expStatus + "\nFound: " + response); } }
private static void addFolder(FileSystem fs, Path p, JsonArray succeeded, JsonArray failed) { try { if (fs == null) return; for (FileStatus file : fs.listStatus(p)) { Path pfs = file.getPath(); if (file.isDir()) { addFolder(fs, pfs, succeeded, failed); } else { Key k = Key.make(pfs.toString()); long size = file.getLen(); Value val = null; if (pfs.getName().endsWith(Extensions.JSON)) { JsonParser parser = new JsonParser(); JsonObject json = parser.parse(new InputStreamReader(fs.open(pfs))).getAsJsonObject(); JsonElement v = json.get(Constants.VERSION); if (v == null) throw new RuntimeException("Missing version"); JsonElement type = json.get(Constants.TYPE); if (type == null) throw new RuntimeException("Missing type"); Class c = Class.forName(type.getAsString()); OldModel model = (OldModel) c.newInstance(); model.fromJson(json); } else if (pfs.getName().endsWith(Extensions.HEX)) { // Hex file? FSDataInputStream s = fs.open(pfs); int sz = (int) Math.min(1L << 20, size); // Read up to the 1st meg byte[] mem = MemoryManager.malloc1(sz); s.readFully(mem); // Convert to a ValueArray (hope it fits in 1Meg!) ValueArray ary = new ValueArray(k, 0).read(new AutoBuffer(mem)); val = new Value(k, ary, Value.HDFS); } else if (size >= 2 * ValueArray.CHUNK_SZ) { val = new Value( k, new ValueArray(k, size), Value.HDFS); // ValueArray byte wrapper over a large file } else { val = new Value(k, (int) size, Value.HDFS); // Plain Value val.setdsk(); } DKV.put(k, val); Log.info("PersistHdfs: DKV.put(" + k + ")"); JsonObject o = new JsonObject(); o.addProperty(Constants.KEY, k.toString()); o.addProperty(Constants.FILE, pfs.toString()); o.addProperty(Constants.VALUE_SIZE, file.getLen()); succeeded.add(o); } } } catch (Exception e) { Log.err(e); JsonObject o = new JsonObject(); o.addProperty(Constants.FILE, p.toString()); o.addProperty(Constants.ERROR, e.getMessage()); failed.add(o); } }
@Override public void store(Value v) { // Should be used only if ice goes to HDFS assert this == getIce(); assert !v.isPersisted(); byte[] m = v.memOrLoad(); assert (m == null || m.length == v._max); // Assert not saving partial files store(new Path(_iceRoot, getIceName(v)), m); v.setdsk(); // Set as write-complete to disk }
/* Returns a negative integer, zero, or a positive integer as v1 is less than, equal to, or greater v2. NOTE: assume values are ints. */ public static int compareIntValues(Value val1, Value val2) { try { int vval1 = new Integer(val1.toString()).intValue(); int vval2 = new Integer(val2.toString()).intValue(); if (vval1 > vval2) return 1; else if (vval2 > vval1) return -1; return 0; } catch (Exception e) { Utility.Dprint(" Error in Variable.compareValues(): Vals are not ints." + e, 0); } return 0; }
/** * @ast method * @aspect Expressions * @declaredat * /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/Expressions.jrag:84 */ public soot.Value eval(Body b) { TypeDecl dest = getDest().type(); TypeDecl source = getSource().type(); if (dest.isString()) { Value lvalue = getDest().eval(b); Value v = asImmediate(b, lvalue); // new StringBuffer(left) Local local = b.newTemp(b.newNewExpr(lookupType("java.lang", "StringBuffer").sootRef(), this)); b.setLine(this); b.add( b.newInvokeStmt( b.newSpecialInvokeExpr( local, Scene.v() .getMethod("<java.lang.StringBuffer: void <init>(java.lang.String)>") .makeRef(), v, this), this)); // append right Local rightResult = b.newTemp( b.newVirtualInvokeExpr( local, lookupType("java.lang", "StringBuffer") .methodWithArgs("append", new TypeDecl[] {source.stringPromotion()}) .sootRef(), asImmediate(b, getSource().eval(b)), this)); // toString Local result = b.newTemp( b.newVirtualInvokeExpr( rightResult, Scene.v() .getMethod("<java.lang.StringBuffer: java.lang.String toString()>") .makeRef(), this)); Value v2 = lvalue instanceof Local ? lvalue : (Value) lvalue.clone(); getDest().emitStore(b, v2, result, this); return result; } else { return super.eval(b); } }
static Value lazyArrayChunk(Key key) { Key arykey = ValueArray.getArrayKey(key); // From the base file key long off = ValueArray.getChunkOffset(key); // The offset long size = getFileForKey(arykey).length(); long rem = size - off; // the last chunk can be fat, so it got packed into the earlier chunk if (rem < ValueArray.CHUNK_SZ && off > 0) return null; int sz = (rem >= ValueArray.CHUNK_SZ * 2) ? (int) ValueArray.CHUNK_SZ : (int) rem; Value val = new Value(key, sz, Value.NFS); val.setdsk(); // But its already on disk. return val; }
/** * Returns a parameter. * * @param value value * @param name name * @param declared variable declaration flags * @return parameter * @throws QueryException HTTP exception */ private RestXqParam param(final Value value, final QNm name, final boolean[] declared) throws QueryException { // [CG] RESTXQ: allow identical field names? final long vs = value.size(); if (vs < 2) error(ANN_PARAMS, "%", name.string(), 2); // name of parameter final String key = toString(value.itemAt(0), name); // variable template final QNm qnm = checkVariable(toString(value.itemAt(1), name), declared); // default value final ValueBuilder vb = new ValueBuilder(); for (int v = 2; v < vs; v++) vb.add(value.itemAt(v)); return new RestXqParam(qnm, key, vb.value()); }
/** * Builds the thesaurus. * * @param value input nodes * @throws QueryException query exception */ private void build(final Value value) throws QueryException { final Value synonyms = nodes("*:synonym", value); if (synonyms.isEmpty()) return; final ThesNode term = node(text("*:term", value)); for (final Item synonym : synonyms) { final ThesNode sterm = node(text("*:term", synonym)); final byte[] rs = text("*:relationship", synonym); term.add(sterm, rs); final byte[] srs = RSHIPS.get(rs); if (srs != null) sterm.add(term, srs); build(synonyms); } }
// Read up to 'len' bytes of Value. Value should already be persisted to // disk. A racing delete can trigger a failure where we get a null return, // but no crash (although one could argue that a racing load&delete is a bug // no matter what). @Override public byte[] load(Value v) { long skip = 0; Key k = v._key; // Convert an arraylet chunk into a long-offset from the base file. if (k._kb[0] == Key.ARRAYLET_CHUNK) { skip = ValueArray.getChunkOffset(k); // The offset k = ValueArray.getArrayKey(k); // From the base file key } if (k._kb[0] == Key.DVEC) { skip = water.fvec.NFSFileVec.chunkOffset(k); // The offset } try { FileInputStream s = null; try { s = new FileInputStream(getFileForKey(k)); FileChannel fc = s.getChannel(); fc.position(skip); AutoBuffer ab = new AutoBuffer(fc, true, Value.NFS); byte[] b = ab.getA1(v._max); ab.close(); assert v.isPersisted(); return b; } finally { if (s != null) s.close(); } } catch (IOException e) { // Broken disk / short-file??? H2O.ignore(e); return null; } }
/** * Parses the S-Expression from the lexer output. The lexer should be positioned on the first * symbol after the opening parenthesis. * * @return the parse tree of the input * @throws IOException if a read error occurs in the lexer * @throws ParsingException if the input cannot be parsed successfully */ private Expression parseSymbolicExpression() throws IOException, ParsingException { Expression expr = new Expression(lexer.sval); int t = lexer.nextToken(); while (t != StreamTokenizer.TT_EOF) { switch (t) { case ')': if (stack.empty()) return expr; stack.peek().addOperand(expr); expr = stack.pop(); break; case '(': // descend into a sub-expression stack.push(expr); if (lexer.nextToken() != StreamTokenizer.TT_WORD) { throw new ParsingException("Expected symbol. Got: " + lexer.ttype); } expr = new Expression(lexer.sval); break; case StreamTokenizer.TT_WORD: try { // test for a number expr.addOperand(Value.newInt(Integer.parseInt(lexer.sval))); } catch (NumberFormatException ignored) { // fall back on a symbol expr.addOperand(lexer.sval); } break; default: throw new ParsingException("Unknown token type: " + lexer.ttype); } t = lexer.nextToken(); } throw new ParsingException("Expected end of input. Got: " + lexer.ttype); }
/** * Populates a DataValue from the supplied array of tokens. * * @param tokens The tokens to use when building a DataValue. * @param destValue That this populator is filling with content. */ @Override void populate(final String[] tokens, final Value destValue) { // BugzID:722 - Only populate the value if we have one from the file if (tokens.length > DATA_INDEX) { destValue.set(stripEscChars(tokens[DATA_INDEX])); } }
private void commandPrint(StringTokenizer t, boolean dumpObject) throws NoSessionException { if (!t.hasMoreTokens()) { // ### Probably confused if expresion contains whitespace. env.error("No expression specified."); return; } ThreadReference current = context.getCurrentThread(); if (current == null) { env.failure("No default thread specified: " + "use the \"thread\" command first."); return; } StackFrame frame; try { frame = context.getCurrentFrame(current); if (frame == null) { env.failure("Thread has not yet created any stack frames."); return; } } catch (VMNotInterruptedException e) { env.failure("Target VM must be in interrupted state."); return; } while (t.hasMoreTokens()) { String expr = t.nextToken(""); Value val = null; try { val = runtime.evaluate(frame, expr); } catch (Exception e) { env.error("Exception: " + e); // ### Fix this! } if (val == null) { return; // Error message already printed } OutputSink out = env.getOutputSink(); if (dumpObject && (val instanceof ObjectReference) && !(val instanceof StringReference)) { ObjectReference obj = (ObjectReference) val; ReferenceType refType = obj.referenceType(); out.println(expr + " = " + val.toString() + " {"); dump(out, obj, refType, refType); out.println("}"); } else { out.println(expr + " = " + val.toString()); } out.show(); } }
// Store Value v to disk. static void fileStore(Value v) { // Only the home node does persistence on NFS if (!v._key.home()) return; // A perhaps useless cutout: the upper layers should test this first. if (v.isPersisted()) return; // Never store arraylets on NFS, instead we'll store the entire array. assert !v.isArray(); try { File f = getFileForKey(v._key); f.mkdirs(); FileOutputStream s = new FileOutputStream(f); try { byte[] m = v.memOrLoad(); assert (m == null || m.length == v._max); // Assert not saving partial files if (m != null) new AutoBuffer(s.getChannel(), false, Value.NFS).putA1(m, m.length).close(); v.setdsk(); // Set as write-complete to disk } finally { s.close(); } } catch (IOException e) { H2O.ignore(e); } }
@Override public void postToFeed( final User user, final Entity entity, final Point originalPoint, final Value value, final FeedType type) throws NimbitsException { final Point point = getFeedPoint(user); if (point != null) { final FeedValue feedValue = new FeedValueModel(valueToHtml(entity, originalPoint, value), value.getData(), type); final String json = GsonFactory.getSimpleInstance().toJson(feedValue); final Value v = ValueModelFactory.createValueModel(value, json); RecordedValueServiceFactory.getInstance().recordValue(user, point, v, false); } }
/** * Populates a DataValue from the supplied array of tokens. * * @param tokens The tokens to use when building a DataValue. * @param destValue That this populator is filling with content. */ @Override void populate(final String[] tokens, final Value destValue) { // BugzID:722 - Only populate the value if we have one from the file if (tokens.length > DATA_INDEX) { String text = ""; for (int i = DATA_INDEX; i < tokens.length; i++) { text = text.concat(tokens[i]); if (i < (tokens.length - 1)) { text = text.concat(","); } } destValue.set(stripEscChars(text)); } }
private String valueToHtml(final Entity entity, final Entity point, final Value value) { final StringBuilder sb = new StringBuilder(SIZE); if (!(Double.compare(value.getDoubleValue(), Const.CONST_IGNORED_NUMBER_VALUE) == 0)) { sb.append("<img style=\"float:left\" src=\"") .append(ServerInfoImpl.getFullServerURL(this.getThreadLocalRequest())); switch (value.getAlertState()) { case LowAlert: sb.append("/resources/images/point_low.png\">"); break; case HighAlert: sb.append("/resources/images/point_high.png\">"); break; case IdleAlert: sb.append("/resources/images/point_idle.png\">"); break; case OK: sb.append("/resources/images/point_ok.png\">"); break; } } if (entity != null && point != null) { sb.append(" "); if (!(Double.compare(value.getDoubleValue(), Const.CONST_IGNORED_NUMBER_VALUE) == 0)) { sb.append("Alert Status:").append(value.getAlertState().name()); sb.append("<br>Value:").append(value.getDoubleValue()); } if (!Utils.isEmptyString(value.getNote())) { sb.append("<br>Note:").append(value.getNote()); } sb.append("<a href=\"#\" onclick=\"window.open('report.html?uuid=") .append(point.getKey()) .append("', 'Report',") .append("'height=800,width=800,toolbar=0,status=0,location=0' );\" >") .append(" [more]</a>"); } return sb.toString(); }
@Override public void delete(final Value v) { assert this == getIce(); assert !v.isPersisted(); // Upper layers already cleared out run( new Callable() { @Override public Object call() throws Exception { Path p = new Path(_iceRoot, getIceName(v)); FileSystem fs = FileSystem.get(p.toUri(), CONF); fs.delete(p, true); if (v.isArray()) { // Also nuke directory if the top-level ValueArray dies p = new Path(_iceRoot, getIceDirectory(v._key)); fs = FileSystem.get(p.toUri(), CONF); fs.delete(p, true); } return null; } }, false, 0); }
public void generate(String className, PrintWriter out) throws IOException, GraphUtilException, GenerationException { // be sure to have at least the uri constants generated if (stringGeneration == null && uriGeneration == null) { uriGeneration = GenerationSetting.createDefault(caseFormat, "", ""); // throw new GenerationException("no generation settings present, please set explicitly"); } log.trace("classname: {}", className); if (StringUtils.isBlank(name)) { name = className; } if (StringUtils.isBlank(prefix)) { throw new GenerationException("could not detect prefix, please set explicitly"); } else { log.debug("prefix: {}", prefix); } Pattern pattern = Pattern.compile(Pattern.quote(getPrefix()) + "(.+)"); ConcurrentMap<String, URI> splitUris = new ConcurrentHashMap<>(); for (Resource nextSubject : model.subjects()) { if (nextSubject instanceof URI) { Matcher matcher = pattern.matcher(nextSubject.stringValue()); if (matcher.find()) { String k = matcher.group(1); URI putIfAbsent = splitUris.putIfAbsent(k, (URI) nextSubject); if (putIfAbsent != null) { log.warn( "Conflicting keys found: uri={} key={} existing={}", nextSubject.stringValue(), k, putIfAbsent); } } } } // print // package is optional if (StringUtils.isNotBlank(packageName)) { out.printf("package %s;%n%n", getPackageName()); } // imports out.println("import org.openrdf.model.URI;"); out.println("import org.openrdf.model.ValueFactory;"); out.println("import org.openrdf.model.impl.ValueFactoryImpl;"); out.println(); final URI pfx = new URIImpl(prefix); Literal oTitle = getFirstExistingObjectLiteral(model, pfx, getPreferredLanguage(), LABEL_PROPERTIES); Literal oDescr = getFirstExistingObjectLiteral(model, pfx, getPreferredLanguage(), COMMENT_PROPERTIES); Set<Value> oSeeAlso = model.filter(pfx, RDFS.SEEALSO, null).objects(); // class JavaDoc out.println("/**"); if (oTitle != null) { out.printf( " * %s.%n", WordUtils.wrap(oTitle.getLabel().replaceAll("\\s+", " "), 70, "\n * ", false)); out.println(" * <p>"); } if (oDescr != null) { out.printf( " * %s.%n", WordUtils.wrap(oDescr.getLabel().replaceAll("\\s+", " "), 70, "\n * ", false)); out.println(" * <p>"); } out.printf(" * Namespace %s.%n", name); out.printf(" * Prefix: {@code <%s>}%n", prefix); if (!oSeeAlso.isEmpty()) { out.println(" *"); for (Value s : oSeeAlso) { if (s instanceof URI) { out.printf(" * @see <a href=\"%s\">%s</a>%n", s.stringValue(), s.stringValue()); } } } out.println(" */"); // class Definition out.printf("public class %s {%n", className); out.println(); // constants out.printf(getIndent(1) + "/** {@code %s} **/%n", prefix); out.printf(getIndent(1) + "public static final String NAMESPACE = \"%s\";%n", prefix); out.println(); out.printf(getIndent(1) + "/** {@code %s} **/%n", name.toLowerCase()); out.printf(getIndent(1) + "public static final String PREFIX = \"%s\";%n", name.toLowerCase()); out.println(); List<String> keys = new ArrayList<>(); keys.addAll(splitUris.keySet()); Collections.sort(keys, String.CASE_INSENSITIVE_ORDER); // do the string constant generation (if set) if (stringGeneration != null) { for (String key : keys) { final Literal comment = getFirstExistingObjectLiteral( model, splitUris.get(key), getPreferredLanguage(), COMMENT_PROPERTIES); final Literal label = getFirstExistingObjectLiteral( model, splitUris.get(key), getPreferredLanguage(), LABEL_PROPERTIES); out.println(getIndent(1) + "/**"); if (label != null) { out.printf(getIndent(1) + " * %s%n", label.getLabel()); out.println(getIndent(1) + " * <p>"); } out.printf(getIndent(1) + " * {@code %s}.%n", splitUris.get(key).stringValue()); if (comment != null) { out.println(getIndent(1) + " * <p>"); out.printf( getIndent(1) + " * %s%n", WordUtils.wrap( comment.getLabel().replaceAll("\\s+", " "), 70, "\n" + getIndent(1) + " * ", false)); } out.println(getIndent(1) + " *"); out.printf(getIndent(1) + " * @see <a href=\"%s\">%s</a>%n", splitUris.get(key), key); out.println(getIndent(1) + " */"); final String nextKey = cleanKey( // NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting String.format( "%s%s%s", StringUtils.defaultString(stringGeneration.getConstantPrefix()), doCaseFormatting(key, stringGeneration.getCaseFormat()), StringUtils.defaultString(stringGeneration.getConstantSuffix()))); checkField(className, nextKey); out.printf( getIndent(1) + "public static final String %s = %s.NAMESPACE + \"%s\";%n", nextKey, className, key); out.println(); } } // do the entire uri constant generation if (uriGeneration != null) { for (String key : keys) { Literal comment = getFirstExistingObjectLiteral( model, splitUris.get(key), getPreferredLanguage(), COMMENT_PROPERTIES); Literal label = getFirstExistingObjectLiteral( model, splitUris.get(key), getPreferredLanguage(), LABEL_PROPERTIES); out.println(getIndent(1) + "/**"); if (label != null) { out.printf(getIndent(1) + " * %s%n", label.getLabel()); out.println(getIndent(1) + " * <p>"); } out.printf(getIndent(1) + " * {@code %s}.%n", splitUris.get(key).stringValue()); if (comment != null) { out.println(getIndent(1) + " * <p>"); out.printf( getIndent(1) + " * %s%n", WordUtils.wrap( comment.getLabel().replaceAll("\\s+", " "), 70, "\n" + getIndent(1) + " * ", false)); } out.println(getIndent(1) + " *"); out.printf(getIndent(1) + " * @see <a href=\"%s\">%s</a>%n", splitUris.get(key), key); out.println(getIndent(1) + " */"); final String nextKey = cleanKey( // NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting String.format( "%s%s%s", StringUtils.defaultString(uriGeneration.getConstantPrefix()), doCaseFormatting(key, uriGeneration.getCaseFormat()), StringUtils.defaultString(uriGeneration.getConstantSuffix()))); // String nextKey = cleanKey(doCaseFormatting(key, uriGeneration.getCaseFormat())); checkField(className, nextKey); out.printf(getIndent(1) + "public static final URI %s;%n", nextKey); out.println(); } // static init out.println(getIndent(1) + "static {"); out.printf(getIndent(2) + "ValueFactory factory = ValueFactoryImpl.getInstance();%n"); out.println(); for (String key : keys) { final String nextKey = cleanKey( // NOTE: CONSTANT PREFIX and constant SUFFIX are NOT part of caseFormatting String.format( "%s%s%s", StringUtils.defaultString(uriGeneration.getConstantPrefix()), doCaseFormatting(key, uriGeneration.getCaseFormat()), StringUtils.defaultString(uriGeneration.getConstantSuffix()))); out.printf( getIndent(2) + "%s = factory.createURI(%s.NAMESPACE, \"%s\");%n", nextKey, className, key); } out.println(getIndent(1) + "}"); out.println(); } // private contructor to avoid instances out.printf(getIndent(1) + "private %s() {%n", className); out.println(getIndent(2) + "//static access only"); out.println(getIndent(1) + "}"); out.println(); // class end out.println("}"); out.flush(); }
/** * Get the domain index of the given value. * * @param v a value within the domain of this variable. * @return domain index corresponding to the given value or -1 if the value is not within the * domain. */ public int indexOf(Value v) { for (int i = 0; i < domain.length; i++) if (v.equal(domain[i])) return i; return -1; }
/** * Evaluates the specified query. * * @param query query * @return success flag */ final boolean query(final String query) { final Performance p = new Performance(); String error; if (exception != null) { error = Util.message(exception); } else { try { long hits = 0; final boolean run = options.get(MainOptions.RUNQUERY); final boolean serial = options.get(MainOptions.SERIALIZE); final int runs = Math.max(1, options.get(MainOptions.RUNS)); for (int r = 0; r < runs; ++r) { // reuse existing processor instance if (r != 0) qp = null; qp(query, context); parse(p); if (r == 0) plan(false); qp.compile(); info.compiling += p.time(); if (r == 0) plan(true); if (!run) continue; final PrintOutput po = r == 0 && serial ? out : new NullOutput(); try (final Serializer ser = qp.getSerializer(po)) { if (maxResults >= 0) { result = qp.cache(maxResults); info.evaluating += p.time(); result.serialize(ser); hits = result.size(); } else { hits = 0; final Iter ir = qp.iter(); info.evaluating += p.time(); for (Item it; (it = ir.next()) != null; ) { ser.serialize(it); ++hits; checkStop(); } } } qp.close(); info.serializing += p.time(); } // dump some query info // out.flush(); // remove string list if global locking is used and if query is updating if (soptions.get(StaticOptions.GLOBALLOCK) && qp.updating) { info.readLocked = null; info.writeLocked = null; } return info(info.toString(qp, out.size(), hits, options.get(MainOptions.QUERYINFO))); } catch (final QueryException | IOException ex) { exception = ex; error = Util.message(ex); } catch (final ProcException ex) { error = INTERRUPTED; } catch (final StackOverflowError ex) { Util.debug(ex); error = BASX_STACKOVERFLOW.desc; } catch (final RuntimeException ex) { extError(""); Util.debug(info()); throw ex; } finally { // close processor after exceptions if (qp != null) qp.close(); } } return extError(error); }
/* * Generates the sequence of instructions needed to instrument ifStmtUnit * * @param ifStmtUnit: the unit to be instrumented * @return A Chain of Units that represent the instrumentation of ifStmtUnit */ private static Chain<Unit> generateInstrumentationUnits(Unit ifStmtUnit, Body b) { AbstractBinopExpr expression = (AbstractBinopExpr) ((JIfStmt) ifStmtUnit).getCondition(); // implementation of AbstractBinopExpr Value operand1 = expression.getOp1(); Value operand2 = expression.getOp2(); JimpleLocal op1Local = (JimpleLocal) operand1; // Local localOperand = Jimple.v().newLocal("op1", operand1.getType()); // b.getLocals().add(localOperand); // We need to use these operand as Locals or constants /** * JimpleLocal test; if(operand1 instanceof soot.jimple.internal.JimpleLocal) test = * (JimpleLocal)operand1; else test = null; */ String op = expression.getClass().toString(); Chain<Unit> resultUnits = new HashChain<Unit>(); Local tmpRef; // Add locals directely on the top of the body, java.io.printStream tmpRef tmpRef = Jimple.v().newLocal("tmpRef", RefType.v("java.io.PrintStream")); b.getLocals().addFirst(tmpRef); // add "tmpRef = java.lang.System.out" resultUnits.add( Jimple.v() .newAssignStmt( tmpRef, Jimple.v() .newStaticFieldRef( Scene.v() .getField("<java.lang.System: java.io.PrintStream out>") .makeRef()))); { SootMethod toCall = Scene.v().getMethod("<java.io.PrintStream: void println(java.lang.String)>"); resultUnits.add( Jimple.v() .newInvokeStmt( Jimple.v() .newVirtualInvokeExpr( tmpRef, toCall.makeRef(), StringConstant.v("Operande 1: ")))); resultUnits.add( Jimple.v() .newInvokeStmt( Jimple.v() .newVirtualInvokeExpr( tmpRef, toCall.makeRef(), StringConstant.v(operand1.getClass().toString())))); resultUnits.add( Jimple.v() .newInvokeStmt( Jimple.v() .newVirtualInvokeExpr( tmpRef, toCall.makeRef(), StringConstant.v("Operande 2:")))); resultUnits.add( Jimple.v() .newInvokeStmt( Jimple.v() .newVirtualInvokeExpr( tmpRef, toCall.makeRef(), StringConstant.v(operand2.getClass().toString())))); resultUnits.add( Jimple.v() .newInvokeStmt( Jimple.v() .newVirtualInvokeExpr( tmpRef, toCall.makeRef(), StringConstant.v("Operateur: ")))); resultUnits.add( Jimple.v() .newInvokeStmt( Jimple.v().newVirtualInvokeExpr(tmpRef, toCall.makeRef(), StringConstant.v(op)))); } return resultUnits; }
/** * Adds items to the specified list. * * @param value value * @param name name * @param list list to add values to * @throws QueryException HTTP exception */ private void strings(final Value value, final QNm name, final StringList list) throws QueryException { final long vs = value.size(); for (int v = 0; v < vs; v++) list.add(toString(value.itemAt(v), name)); }
/** * Checks a function for RESTFful annotations. * * @return {@code true} if module contains relevant annotations * @throws QueryException query exception */ boolean analyze() throws QueryException { // parse all annotations final EnumSet<HTTPMethod> mth = EnumSet.noneOf(HTTPMethod.class); final boolean[] declared = new boolean[function.args.length]; boolean found = false; final int as = function.ann.size(); for (int a = 0; a < as; a++) { final QNm name = function.ann.names[a]; final Value value = function.ann.values[a]; final byte[] local = name.local(); final byte[] uri = name.uri(); final boolean rexq = eq(uri, QueryText.RESTXQURI); if (rexq) { if (eq(PATH, local)) { // annotation "path" if (path != null) error(ANN_TWICE, "%", name.string()); path = new RestXqPath(toString(value, name)); for (final String s : path) { if (s.trim().startsWith("{")) checkVariable(s, AtomType.AAT, declared); } } else if (eq(CONSUMES, local)) { // annotation "consumes" strings(value, name, consumes); } else if (eq(PRODUCES, local)) { // annotation "produces" strings(value, name, produces); } else if (eq(QUERY_PARAM, local)) { // annotation "query-param" queryParams.add(param(value, name, declared)); } else if (eq(FORM_PARAM, local)) { // annotation "form-param" formParams.add(param(value, name, declared)); } else if (eq(HEADER_PARAM, local)) { // annotation "header-param" headerParams.add(param(value, name, declared)); } else if (eq(COOKIE_PARAM, local)) { // annotation "cookie-param" cookieParams.add(param(value, name, declared)); } else { // method annotations final HTTPMethod m = HTTPMethod.get(string(local)); if (m == null) error(ANN_UNKNOWN, "%", name.string()); if (!value.isEmpty()) { // remember post/put variable if (requestBody != null) error(ANN_TWICE, "%", name.string()); if (m != POST && m != PUT) error(METHOD_VALUE, m); requestBody = checkVariable(toString(value, name), declared); } if (mth.contains(m)) error(ANN_TWICE, "%", name.string()); mth.add(m); } } else if (eq(uri, QueryText.OUTPUTURI)) { // serialization parameters final String key = string(local); final String val = toString(value, name); if (output.get(key) == null) error(UNKNOWN_SER, key); output.set(key, val); } found |= rexq; } if (!mth.isEmpty()) methods = mth; if (found) { if (path == null) error(ANN_MISSING, PATH); for (int i = 0; i < declared.length; i++) if (!declared[i]) error(VAR_UNDEFINED, function.args[i].name.string()); } return found; }
public static byte [] getFirstUnzipedBytes(Value v){ byte [] bits = v.getFirstBytes(); try{ return unzipBytes(bits, guessCompressionMethod(bits)); } catch(Exception e){return null;} }