/** * TDTEngine - constructor for a new Tag Data Translation engine * * @param confdir the string value of the path to a configuration directory consisting of two * subdirectories, <code>schemes</code> and <code>auxiliary</code>. * <p>When the class TDTEngine is constructed, the path to a local directory must be * specified, by passing it as a single string parameter to the constructor method (without * any trailing slash or file separator). e.g. <code> * <pre>TDTEngine engine = new TDTEngine("/opt/TDT");</pre></code> * <p>The specified directory must contain two subdirectories named auxiliary and schemes. The * Tag Data Translation definition files for the various coding schemes should be located * inside the subdirectory called <code>schemes</code>. Any auxiliary lookup files (such as * <code>ManagerTranslation.xml</code>) should be located inside the subdirectory called * <code>auxiliary</code>. * <p>Files within the schemes directory ending in <code>.xml</code> are read in and * unmarshalled using <a href = "http://www.castor.org">Castor</a>. */ public TDTEngine(String confdir) throws FileNotFoundException, MarshalException, ValidationException, TDTException { xmldir = confdir; long t = System.currentTimeMillis(); File[] dir = new java.io.File(confdir + File.separator + "schemes").listFiles(new XMLFilenameFilter()); // java.util.Arrays.sort(dir); // Sort it if (dir == null) throw new TDTException("Cannot find schemes in " + confdir); Unmarshaller unmar = new Unmarshaller(); for (File f : dir) { EpcTagDataTranslation tdt = (EpcTagDataTranslation) unmar.unmarshal(EpcTagDataTranslation.class, new FileReader(f)); initFromTDT(tdt); } // need to populate the hashmap gs1cpi from the ManagerTranslation.xml table in auxiliary. // Unmarshaller unmar = new Unmarshaller(); GEPC64Table cpilookup = (GEPC64Table) unmar.unmarshal( GEPC64Table.class, new FileReader( confdir + File.separator + "auxiliary" + File.separator + "ManagerTranslation.xml")); for (Enumeration e = cpilookup.enumerateEntry(); e.hasMoreElements(); ) { Entry entry = (Entry) e.nextElement(); String comp = entry.getCompanyPrefix(); String indx = Integer.toString(entry.getIndex()); gs1cpi.put(indx, comp); gs1cpi.put(comp, indx); } // System.out.println("Loaded schemas in " + // (System.currentTimeMillis() - t) // + " millisecs"); }
/** * Adds additional entries to the extraparams hashmap by processing various rules defined in the * TDT definition files. Typically used for string processing functions, lookup in tables, * calculation of check digits etc. */ private void processRules(Map<String, String> extraparams, Rule tdtrule) { String tdtfunction = tdtrule.getFunction(); int openbracket = tdtfunction.indexOf("("); assert openbracket != -1; String params = tdtfunction.substring(openbracket + 1, tdtfunction.length() - 1); String rulename = tdtfunction.substring(0, openbracket); String[] parameter = params.split(","); String newfieldname = tdtrule.getNewFieldName(); // System.out.println(tdtfunction + " " + parameter[0] + " " + extraparams.get(parameter[0])); /** * Stores in the hashmap extraparams the value obtained from a lookup in a specified XML table. * * <p>The first parameter is the given value already known. This is denoted as $1 in the * corresponding XPath expression * * <p>The second parameter is the string filename of the table which must be present in the * auxiliary subdirectory * * <p>The third parameter is the column in which the supplied input value should be sought * * <p>The fourth parameter is the column whose value should be read for the corresponding row, * in order to obtain the result of the lookup. * * <p>The rule in the definition file may contain an XPath expression and a URL where the table * may be obtained. */ if (rulename.equals("TABLELOOKUP")) { // parameter[0] is given value // parameter[1] is table // parameter[2] is input column supplied // parameter[3] is output column required assert parameter.length == 4 : "incorrect number of parameters to tablelookup " + params; if (parameter[1].equals("tdt64bitcpi")) { String s = extraparams.get(parameter[0]); assert s != null : tdtfunction + " when " + parameter[0] + " is null"; String t = gs1cpi.get(s); assert t != null : "gs1cpi[" + s + "] is null"; assert newfieldname != null; extraparams.put(newfieldname, t); // extraparams.put(newfieldname, gs1cpi.get(extraparams.get(parameter[0]))); } else { // JPB! the following is untested String tdtxpath = tdtrule.getTableXPath(); String tdttableurl = tdtrule.getTableURL(); String tdtxpathsub = tdtxpath.replaceAll("\\$1", extraparams.get(parameter[0])); extraparams.put(newfieldname, xpathlookup("ManagerTranslation.xml", tdtxpathsub)); } } /** * Stores the length of the specified string under the new fieldname specified by the * corresponding rule of the definition file. */ if (rulename.equals("LENGTH")) { assert extraparams.get(parameter[0]) != null : tdtfunction + " when " + parameter[0] + " is null"; if (extraparams.get(parameter[0]) != null) { extraparams.put(newfieldname, Integer.toString(extraparams.get(parameter[0]).length())); } } /** * Stores a GS1 check digit in the extraparams hashmap, keyed under the new fieldname specified * by the corresponding rule of the definition file. */ if (rulename.equals("GS1CHECKSUM")) { assert extraparams.get(parameter[0]) != null : tdtfunction + " when " + parameter[0] + " is null"; if (extraparams.get(parameter[0]) != null) { extraparams.put(newfieldname, gs1checksum(extraparams.get(parameter[0]))); } } /** * Obtains a substring of the string provided as the first parameter. If only a single second * parameter is specified, then this is considered as the start index and all characters from * the start index onwards are stored in the extraparams hashmap under the key named * 'newfieldname' in the corresponding rule of the definition file. If a second and third * parameter are specified, then the second parameter is the start index and the third is the * length of characters required. A substring consisting characters from the start index up to * the required length of characters is stored in the extraparams hashmap, keyed under the new * fieldname specified by the corresponding rule of the defintion file. */ if (rulename.equals("SUBSTR")) { assert extraparams.get(parameter[0]) != null : tdtfunction + " when " + parameter[0] + " is null"; if (parameter.length == 2) { if (extraparams.get(parameter[0]) != null) { int start = getIntValue(parameter[1], extraparams); if (start >= 0) { extraparams.put(newfieldname, extraparams.get(parameter[0]).substring(start)); } } } if (parameter.length == 3) { // need to check that this variation is correct - c.f. Perl substr assert extraparams.get(parameter[0]) != null : tdtfunction + " when " + parameter[0] + " is null"; if (extraparams.get(parameter[0]) != null) { int start = getIntValue(parameter[1], extraparams); int end = getIntValue(parameter[2], extraparams); if ((start >= 0) && (end >= 0)) { extraparams.put( newfieldname, extraparams.get(parameter[0]).substring(start, start + end)); } } } } /** * Concatenates specified string parameters together. Literal values must be enclosed within * single or double quotes or consist of unquoted digits. Other unquoted strings are considered * as fieldnames and the corresponding value from the extraparams hashmap are inserted. The * result of the concatenation (and substitution) of the strings is stored as a new entry in the * extraparams hashmap, keyed under the new fieldname specified by the rule. */ if (rulename.equals("CONCAT")) { StringBuilder buffer = new StringBuilder(); for (int p1 = 0; p1 < parameter.length; p1++) { Matcher matcher = Pattern.compile("\"(.*?)\"|'(.*?)'|[0-9]").matcher(parameter[p1]); if (matcher.matches()) { buffer.append(parameter[p1]); } else { assert extraparams.get(parameter[p1]) != null : tdtfunction + " when " + parameter[p1] + " is null"; if (extraparams.get(parameter[p1]) != null) { buffer.append(extraparams.get(parameter[p1])); } } } extraparams.put(newfieldname, buffer.toString()); } }