/** * Retrieves the specified value. Throws an error if value cannot be read. * * @param key key * @param c expected type * @return result */ private Object get(final Object[] key, final Class<?> c) { final Object entry = props.get(key[0].toString()); if (entry == null) Util.notexpected("Property " + key[0] + " not defined."); final Class<?> cc = entry.getClass(); if (c != cc) Util.notexpected("Property '" + key[0] + "' is a " + Util.name(cc)); return entry; }
@Override public JapaneseTokenizer init(final byte[] txt) { String source = string(txt); if (wc) { // convert wide-space to space source = source.replace('\u3000', '\u0020'); } final ArrayList<?> morpheme = (ArrayList<?>) Reflect.invoke(parse, tagger, source); final ArrayList<Morpheme> list = new ArrayList<>(); try { int prev = 0; final int ms = morpheme.size(); for (int i = 0; i < ms; i++) { final Object m = morpheme.get(i); final String srfc = surface.get(m).toString(); final String ftr = feature.get(m).toString(); final int strt = start.getInt(m); if (i != 0) { final int l = strt - prev; if (l != 0) { list.add(new Morpheme(source.substring(strt - 1, strt + l - 1), KIGOU_FEATURE)); } } prev = srfc.length() + strt; // separates continuous mark (ASCII) boolean cont = true; final ArrayList<Morpheme> marks = new ArrayList<>(); final int sl = srfc.length(); for (int s = 0; s < sl; s++) { final String c = String.valueOf(srfc.charAt(s)); final byte[] t = token(c); if (t.length == 1) { if (letter(t[0]) || digit(t[0])) cont = false; else marks.add(new Morpheme(c, KIGOU_FEATURE)); } else { cont = false; } } if (cont) list.addAll(marks); else list.add(new Morpheme(srfc, ftr)); } } catch (final Exception ex) { Util.errln(Util.className(this) + ": " + ex); } tokenList = list; tokens = list.iterator(); return this; }
public Object computeReadValue() { Object readValue; try { readValue = MethodInvocationManager.invokeMethod(readMethod, parentObject, readMethodParams); return Util.deepCopy(readValue); } catch (Exception e) { return null; } }
/** * Returns a string representation of all found arguments. * * @param args array with arguments * @return string representation */ static String foundArgs(final Value[] args) { // compose found arguments final StringBuilder sb = new StringBuilder(); for (final Value v : args) { if (sb.length() != 0) sb.append(", "); sb.append(v instanceof Jav ? Util.className(((Jav) v).toJava()) : v.seqType()); } return sb.toString(); }
/** * Sets the specified value after casting it to the correct type. * * @param key key * @param val value * @return final value, or {@code null} if the key has not been found */ public final synchronized String set(final String key, final String val) { final Object type = get(key); if (type == null) return null; String v = val; if (type instanceof Boolean) { final boolean b = val == null || val.isEmpty() ? !((Boolean) type) : Util.yes(val); setObject(key, b); v = Util.flag(b); } else if (type instanceof Integer) { setObject(key, Integer.parseInt(val)); v = String.valueOf(get(key)); } else if (type instanceof String) { setObject(key, val); } else { Util.notexpected("Unknown property type: " + type.getClass().getSimpleName()); } return v; }
/** Constructor, initializing the default options. */ protected AProp() { try { for (final Field f : getClass().getFields()) { final Object obj = f.get(null); if (!(obj instanceof Object[])) continue; final Object[] arr = (Object[]) obj; props.put(arr[0].toString(), arr[1]); } } catch (final Exception ex) { Util.notexpected(ex); } }
static { IOFile dic = null; if (Reflect.available(PATTERN)) { dic = new IOFile(LANG); if (!dic.exists()) { dic = new IOFile(Prop.HOME, "etc/" + LANG); if (!dic.exists()) { available = false; } } } else { available = false; } if (available) { Class<?> clz = Reflect.find(PATTERN); if (clz == null) { Util.debug("Could not initialize Igo Japanese lexer."); } else { /* Igo constructor. */ final Constructor<?> tgr = Reflect.find(clz, String.class); tagger = Reflect.get(tgr, dic.path()); if (tagger == null) { available = false; Util.debug("Could not initialize Igo Japanese lexer."); } else { parse = Reflect.method(clz, "parse", CharSequence.class); if (parse == null) { Util.debug("Could not initialize Igo lexer method."); } clz = Reflect.find("net.reduls.igo.Morpheme"); surface = Reflect.field(clz, "surface"); feature = Reflect.field(clz, "feature"); start = Reflect.field(clz, "start"); } } } }
public void init( CommandListener theListener, MethodProxy theWriteMethod, Object theParentObject, Object[] theParams, MethodProxy theReadMethod // , // Object[] theReadMethodParams ) { // frame = theFrame; writeMethod = theWriteMethod; // undoWriteMethod = uiBean.getUndo(theParentObject, writeMethod); // if (undoWriteMethod == null) undoWriteMethod = writeMethod; parentObject = theParentObject; params = theParams; readMethod = theReadMethod; // readMethodParams = theReadMethodParams; listener = theListener; undoWriteMethodParams = Util.copy(theParams); readMethodParams = createReadMethodParams(theParams); isVoid = theWriteMethod.getReturnType() == theWriteMethod.getDeclaringClass().voidType(); }
/** * Converts an HTML document to XML. * * @param io io reference * @param opts html options * @return parser * @throws IOException I/O exception */ private static IO toXML(final IO io, final HtmlOptions opts) throws IOException { // reader could not be initialized; fall back to XML if (READER == null) return io; try { // tries to extract the encoding from the input final TextInput ti = new TextInput(io); String enc = ti.encoding(); final byte[] content = ti.content(); // looks for a charset definition final byte[] encoding = token("charset="); int cs = indexOf(content, encoding); if (cs > 0) { // extracts the encoding string cs += encoding.length; int ce = cs; final int cl = content.length; while (++ce < cl && content[ce] > 0x28) ; enc = string(substring(content, cs, ce)); } // define input final InputSource is = new InputSource(new ArrayInput(content)); is.setEncoding(supported(enc) ? normEncoding(enc) : UTF8); // define output final StringWriter sw = new StringWriter(); final XMLReader reader = (XMLReader) Reflect.get(READER); final Object writer = Reflect.get(WRITER, sw); // set TagSoup options if (opts.get(HtmlOptions.HTML)) { reader.setFeature("http://xml.org/sax/features/namespaces", false); opt("method", "html"); opt("omit-xml-declaration", "yes"); } if (opts.get(HtmlOptions.NONS)) reader.setFeature("http://xml.org/sax/features/namespaces", false); if (opts.get(HtmlOptions.OMITXML)) opt("omit-xml-declaration", "yes"); if (opts.get(HtmlOptions.NOBOGONS)) reader.setFeature(FEATURES + "ignore-bogons", true); if (opts.get(HtmlOptions.NODEFAULTS)) reader.setFeature(FEATURES + "default-attributes", false); if (opts.get(HtmlOptions.NOCOLONS)) reader.setFeature(FEATURES + "translate-colons", true); if (opts.get(HtmlOptions.NORESTART)) reader.setFeature(FEATURES + "restart-elements", false); if (opts.get(HtmlOptions.IGNORABLE)) reader.setFeature(FEATURES + "ignorable-whitespace", true); if (opts.get(HtmlOptions.EMPTYBOGONS)) reader.setFeature(FEATURES + "bogons-empty", true); if (opts.get(HtmlOptions.ANY)) reader.setFeature(FEATURES + "bogons-empty", false); if (opts.get(HtmlOptions.NOROOTBOGONS)) reader.setFeature(FEATURES + "root-bogons", false); if (opts.get(HtmlOptions.NOCDATA)) reader.setFeature(FEATURES + "cdata-elements", false); if (opts.get(HtmlOptions.LEXICAL)) reader.setProperty("http://xml.org/sax/properties/lexical-handler", writer); if (opts.contains(HtmlOptions.METHOD)) opt("method", opts.get(HtmlOptions.METHOD)); if (opts.contains(HtmlOptions.DOCTYPESYS)) opt("doctype-system", opts.get(HtmlOptions.DOCTYPESYS)); if (opts.contains(HtmlOptions.DOCTYPEPUB)) opt("doctype-public", opts.get(HtmlOptions.DOCTYPEPUB)); if (opts.contains(HtmlOptions.ENCODING)) is.setEncoding(opts.get(HtmlOptions.ENCODING)); // end TagSoup options reader.setContentHandler((ContentHandler) writer); reader.parse(is); return new IOContent(token(sw.toString()), io.name()); } catch (final SAXException ex) { Util.errln(ex); return io; } }
public void runTest() throws Throwable { boolean pass = true; out.println("### framework test bundle :STARTLVL100A start"); try { buA = Util.installBundle(bc, "bundleSLA_test-1.0.0.jar"); sl.setBundleStartLevel(buA, baseLevel + 10); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("framework test bundle " + e + " :STARTLVL100A:FAIL"); } buB = null; try { buB = Util.installBundle(bc, "bundleSLB_test-1.0.0.jar"); sl.setBundleStartLevel(buB, baseLevel + 30); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("framework test bundle " + e + " :STARTLVL100A:FAIL"); } buC = null; try { buC = Util.installBundle(bc, "bundleSLC_test_api-1.0.0.jar"); sl.setBundleStartLevel(buC, baseLevel + 20); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("framework test bundle " + e + " :STARTLVL100A:FAIL"); } try { buA.start(); assertTrue("BundleA should not be ACTIVE", buA.getState() != Bundle.ACTIVE); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("framework test bundle " + e + " :STARTLVL100A:FAIL"); } try { buB.start(); assertTrue("BundleB should not be ACTIVE", buB.getState() != Bundle.ACTIVE); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("framework test bundle " + e + " :STARTLVL100A:FAIL"); } try { buC.start(); assertTrue("BundleC should not be ACTIVE", buC.getState() != Bundle.ACTIVE); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("framework test bundle " + e + " :STARTLVL100A:FAIL"); } syncBListen.clearEvents(); sl.setStartLevel(baseLevel + 30); pass = syncBListen.checkEvents( new BundleEvent[] { new BundleEvent(BundleEvent.STARTED, buA), new BundleEvent(BundleEvent.STARTED, buC), new BundleEvent(BundleEvent.STARTED, buB) }); assertTrue("Bundle A, C, B should start", pass); buD = null; try { buD = Util.installBundle(bc, "bundleSLD_test-1.0.0.jar"); sl.setBundleStartLevel(buD, baseLevel + 15); buD.start(); assertTrue("BundleD should be ACTIVE", buD.getState() == Bundle.ACTIVE); } catch (Exception e) { out.println("Unexpected exception: " + e); e.printStackTrace(); fail("start level test bundle " + e + " :STARTLVL100A:FAIL"); } syncBListen.clearEvents(); Util.updateBundle(bc, buC, "bundleSLC_test_api-1.0.0.jar"); // Check BundleEvent stop/start C pass = syncBListen.checkEvents( new BundleEvent[] { new BundleEvent(BundleEvent.STOPPED, buC), new BundleEvent(BundleEvent.STARTED, buC), }); assertTrue("Bundle C should stop and start", pass); syncBListen.clearEvents(); pa.refreshPackages(new Bundle[] {buA, buB, buC, buD}); // Check BundleEvent stop order B, C, D, A // Check BundleEvent start order A, D, C, B pass = syncBListen.checkEvents( new BundleEvent[] { new BundleEvent(BundleEvent.STOPPED, buB), new BundleEvent(BundleEvent.STOPPED, buC), new BundleEvent(BundleEvent.STOPPED, buD), new BundleEvent(BundleEvent.STOPPED, buA), new BundleEvent(BundleEvent.STARTED, buA), new BundleEvent(BundleEvent.STARTED, buD), new BundleEvent(BundleEvent.STARTED, buC), new BundleEvent(BundleEvent.STARTED, buB) }); assertTrue("Bundle B, C, D, A should stop and start in reverse", pass); buA.uninstall(); buA = null; buB.uninstall(); buB = null; buC.uninstall(); buC = null; buD.uninstall(); buD = null; out.println("### start level test bundle :STARTLVL100A:PASS"); }
/** * Reads the configuration file and initializes the project properties. The file is located in the * project home directory. * * @param prop property file extension */ protected synchronized void read(final String prop) { file = new IOFile(HOME + IO.BASEXSUFFIX + prop); final StringList read = new StringList(); final TokenBuilder err = new TokenBuilder(); if (!file.exists()) { err.addExt("Saving properties in \"%\"..." + NL, file); } else { BufferedReader br = null; try { br = new BufferedReader(new FileReader(file.file())); for (String line; (line = br.readLine()) != null; ) { line = line.trim(); if (line.isEmpty() || line.charAt(0) == '#') continue; final int d = line.indexOf('='); if (d < 0) { err.addExt("%: \"%\" ignored. " + NL, file, line); continue; } final String val = line.substring(d + 1).trim(); String key = line.substring(0, d).trim(); // extract numeric value in key int num = 0; final int ss = key.length(); for (int s = 0; s < ss; ++s) { if (Character.isDigit(key.charAt(s))) { num = Integer.parseInt(key.substring(s)); key = key.substring(0, s); break; } } read.add(key); final Object entry = props.get(key); if (entry == null) { err.addExt("%: \"%\" not found. " + NL, file, key); } else if (entry instanceof String) { props.put(key, val); } else if (entry instanceof Integer) { props.put(key, Integer.parseInt(val)); } else if (entry instanceof Boolean) { props.put(key, Boolean.parseBoolean(val)); } else if (entry instanceof String[]) { if (num == 0) { props.put(key, new String[Integer.parseInt(val)]); } else { ((String[]) entry)[num - 1] = val; } } else if (entry instanceof int[]) { ((int[]) entry)[num] = Integer.parseInt(val); } } } catch (final Exception ex) { err.addExt("% could not be parsed." + NL, file); Util.debug(ex); } finally { if (br != null) try { br.close(); } catch (final IOException ex) { } } } // check if all mandatory files have been read try { if (err.isEmpty()) { boolean ok = true; for (final Field f : getClass().getFields()) { final Object obj = f.get(null); if (!(obj instanceof Object[])) continue; final String key = ((Object[]) obj)[0].toString(); ok &= read.contains(key); } if (!ok) err.addExt("Saving properties in \"%\"..." + NL, file); } } catch (final IllegalAccessException ex) { Util.notexpected(ex); } if (!err.isEmpty()) { Util.err(err.toString()); write(); } }
/** * Returns an error string for an unknown key. * * @param key key * @return error string */ public final synchronized String unknown(final String key) { final String sim = similar(key); return Util.info(sim != null ? Text.UNKNOWN_OPT_SIMILAR_X_X : Text.UNKNOWN_OPTION_X, key, sim); }
/** Writes the properties to disk. */ public final synchronized void write() { final StringBuilder user = new StringBuilder(); BufferedReader br = null; try { // caches options specified by the user if (file.exists()) { br = new BufferedReader(new FileReader(file.file())); for (String line; (line = br.readLine()) != null; ) { if (line.equals(PROPUSER)) break; } for (String line; (line = br.readLine()) != null; ) { user.append(line).append(NL); } } } catch (final Exception ex) { Util.debug(ex); } finally { if (br != null) try { br.close(); } catch (final IOException e) { } } BufferedWriter bw = null; try { bw = new BufferedWriter(new FileWriter(file.file())); bw.write(PROPHEADER + NL); for (final Field f : getClass().getFields()) { final Object obj = f.get(null); if (!(obj instanceof Object[])) continue; final String key = ((Object[]) obj)[0].toString(); final Object val = props.get(key); if (val instanceof String[]) { final String[] str = (String[]) val; bw.write(key + " = " + str.length + NL); final int is = str.length; for (int i = 0; i < is; ++i) { if (str[i] != null) bw.write(key + (i + 1) + " = " + str[i] + NL); } } else if (val instanceof int[]) { final int[] num = (int[]) val; final int ns = num.length; for (int i = 0; i < ns; ++i) { bw.write(key + i + " = " + num[i] + NL); } } else { bw.write(key + " = " + val + NL); } } bw.write(NL + PROPUSER + NL); bw.write(user.toString()); } catch (final Exception ex) { Util.errln("% could not be written.", file); Util.debug(ex); } finally { if (bw != null) try { bw.close(); } catch (final IOException e) { } } }