protected Symbol[] getTokenTable() { if (tokenTable == null) { int maxChar = 0; for (Iterator i = charactersToSymbols.keySet().iterator(); i.hasNext(); ) { Character c = (Character) i.next(); char cv = c.charValue(); if (caseSensitive) { maxChar = Math.max(maxChar, cv); } else { maxChar = Math.max(maxChar, Character.toUpperCase(cv)); maxChar = Math.max(maxChar, Character.toLowerCase(cv)); } } tokenTable = new Symbol[maxChar + 1]; for (Iterator i = charactersToSymbols.entrySet().iterator(); i.hasNext(); ) { Map.Entry me = (Map.Entry) i.next(); Symbol sym = (Symbol) me.getValue(); Character c = (Character) me.getKey(); char cv = c.charValue(); if (caseSensitive) { tokenTable[cv] = sym; } else { tokenTable[Character.toUpperCase(cv)] = sym; tokenTable[Character.toLowerCase(cv)] = sym; } } } return tokenTable; }
public void testCharacter() { Character c; c = 'a'; assertEquals("CharacterSmall", c.charValue(), 'a'); c = '\u1000'; assertEquals("CharacterLarge", c.charValue(), '\u1000'); }
public static void main(String[] args) throws NumberFormatException, IOException { BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); StringBuilder output = new StringBuilder(); int cases = Integer.parseInt(bf.readLine()); for (int i = 0; i < cases; i++) { String keyPhrase = bf.readLine(); String text = bf.readLine().replaceAll("\\s+", ""); Table t = buildTable(keyPhrase); int index = 0; while (index < text.length()) { Character cur = text.charAt(index++); Character next = null; if (index < text.length()) { next = text.charAt(index++); } if (next != null && cur.charValue() == next.charValue()) { index--; next = 'x'; } String cypher = process(cur, next, t); output.append(cypher.toUpperCase()); } output.append("\n"); } System.out.print(output.toString()); }
public ActionForward prepareEditObject( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws FenixServiceException, ClassNotFoundException { Person person = checkUser(); String documentIdNumber = person.getDocumentIdNumber(); DynaActionForm actionForm = (DynaActionForm) form; Integer idPos1Index = (Integer) actionForm.get("idPos1Index"); Integer idPos2Index = (Integer) actionForm.get("idPos2Index"); Integer idPos3Index = (Integer) actionForm.get("idPos3Index"); Character idPos1Value = (Character) actionForm.get("idPos1Value"); Character idPos2Value = (Character) actionForm.get("idPos2Value"); Character idPos3Value = (Character) actionForm.get("idPos3Value"); if (documentIdNumber.charAt(idPos1Index - 1) == idPos1Value.charValue() && documentIdNumber.charAt(idPos2Index - 1) == idPos2Value.charValue() && documentIdNumber.charAt(idPos3Index - 1) == idPos3Value.charValue()) { DomainObject object = getDomainObject(actionForm, "classToManageId"); if (object != null) { request.setAttribute("objectToEdit", object); } } else { request.setAttribute("message", "Who the hell are you!?!?!"); } return mapping.findForward("prepareEditObject"); }
public ActionForward deleteObject( ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws FenixServiceException, ClassNotFoundException { Person person = checkUser(); String documentIdNumber = person.getDocumentIdNumber(); DynaActionForm actionForm = (DynaActionForm) form; Integer idPos1Index = (Integer) actionForm.get("idPos1Index"); Integer idPos2Index = (Integer) actionForm.get("idPos2Index"); Integer idPos3Index = (Integer) actionForm.get("idPos3Index"); Character idPos1Value = (Character) actionForm.get("idPos1Value"); Character idPos2Value = (Character) actionForm.get("idPos2Value"); Character idPos3Value = (Character) actionForm.get("idPos3Value"); if (documentIdNumber.charAt(idPos1Index - 1) == idPos1Value.charValue() && documentIdNumber.charAt(idPos2Index - 1) == idPos2Value.charValue() && documentIdNumber.charAt(idPos3Index - 1) == idPos3Value.charValue()) { String classToDelete = (String) actionForm.get("classToManage"); String classToDeleteId = (String) actionForm.get("classToManageId"); try { DeleteObjectByOID.run(classToDeleteId); request.setAttribute( "message", "Object " + classToDelete + " with ID:" + classToDeleteId + " Deleted. God have mercy of your soul..."); } catch (Exception e) { logger.error(e.getMessage(), e); request.setAttribute( "message", "Error deleting Object " + classToDelete + " with ID:" + classToDeleteId); } } else { request.setAttribute("message", "Who the hell are you!?!?!"); } request.setAttribute("domainClasses", getClasses()); ((DynaActionForm) form).set("method", "prepareEditObject"); return mapping.findForward("chooseClassToManage"); }
public static char valueOf(Character c1, char c2) { if (null == c1) { return c2; } else { return c1.charValue(); } }
/** * Convert a reference to a unicode character. Convert a single numeric character reference or * character entity reference to a unicode character. * * @param string The string to convert. Of the form &xxxx; or &#xxxx; with or without the * leading ampersand or trailing semi-colon. * @return The converted character or '\0' (zero) if the string is an invalid reference. */ public static char convertToChar(String string) { int length; Character item; char ret; ret = 0; length = string.length(); if (0 < length) { if ('&' == string.charAt(0)) { string = string.substring(1); length--; } if (0 < length) { if (';' == string.charAt(length - 1)) string = string.substring(0, --length); if (0 < length) { if ('#' == string.charAt(0)) try { ret = (char) Integer.parseInt(string.substring(1)); } catch (NumberFormatException nfe) { /* failed conversion, return 0 */ } else { item = (Character) refChar.get(string); if (null != item) ret = item.charValue(); } } } } return (ret); }
/** * Move the cursor <i>where</i> characters, withough checking the current buffer. * * @see #where * @param where the number of characters to move to the right or left. */ private final void moveInternal(final int where) throws IOException { // debug ("move cursor " + where + " (" // + buf.cursor + " => " + (buf.cursor + where) + ")"); buf.cursor += where; char c; if (where < 0) { int len = 0; for (int i = buf.cursor; i < buf.cursor - where; i++) { if (buf.getBuffer().charAt(i) == '\t') len += TAB_WIDTH; else len++; } char cbuf[] = new char[len]; Arrays.fill(cbuf, BACKSPACE); out.write(cbuf); return; } else if (buf.cursor == 0) { return; } else if (mask != null) { c = mask.charValue(); } else { printCharacters(buf.buffer.substring(buf.cursor - where, buf.cursor).toCharArray()); return; } // null character mask: don't output anything if (NULL_MASK.equals(mask)) { return; } printCharacters(c, Math.abs(where)); }
@Override public String apply(final String input) { String res = ""; int i = 0; while ((i < input.length())) { { final char testChar = input.charAt(i); final Character _valueOf = Character.valueOf('^'); final char _charValue = _valueOf.charValue(); final boolean _tripleNotEquals = (testChar != _charValue); if (_tripleNotEquals) { final String _res = res; res = (_res + Character.valueOf(testChar)); } else { i++; final String _res_1 = res; final char _charAt = input.charAt(i); final char _upperCase = Character.toUpperCase(_charAt); res = (_res_1 + Character.valueOf(_upperCase)); } i++; } } return res; }
/* */ public Character put(Float ok, Character ov) { /* 262 */ char v = ov.charValue(); /* 263 */ float k = ok.floatValue(); /* */ /* 265 */ int pos = HashCommon.murmurHash3(HashCommon.float2int(k)) & this.mask; /* */ /* 267 */ while (this.used[pos] != 0) { /* 268 */ if (this.key[pos] == k) { /* 269 */ Character oldValue = Character.valueOf(this.value[pos]); /* 270 */ this.value[pos] = v; /* 271 */ return oldValue; /* */ } /* 273 */ pos = pos + 1 & this.mask; /* */ } /* 275 */ this.used[pos] = true; /* 276 */ this.key[pos] = k; /* 277 */ this.value[pos] = v; /* 278 */ if (this.size == 0) { /* 279 */ this.first = (this.last = pos); /* */ /* 281 */ this.link[pos] = -1L; /* */ } /* */ else { /* 284 */ this.link[this.last] ^= (this.link[this.last] ^ pos & 0xFFFFFFFF) & 0xFFFFFFFF; /* 285 */ this.link[pos] = ((this.last & 0xFFFFFFFF) << 32 | 0xFFFFFFFF); /* 286 */ this.last = pos; /* */ } /* 288 */ if (++this.size >= this.maxFill) rehash(HashCommon.arraySize(this.size + 1, this.f)); /* */ /* 290 */ return null; /* */ }
/** * Encode a UTF-16 character into an ANSEL byte * * @param c the ANSEL byte (as a char) * @return the character (in UTF-16) represented by the byte */ public static char encode(char c) { Character b = charToByte.get(Character.valueOf(c)); if (b != null) { return b.charValue(); } return c; }
/* IE that can be sent: - 8.6.1. CALLED NUMBER - 8.6.2. CALLING NUMBER - 8.6.3. CALLING ANI - 8.6.4. CALLING NAME - 8.6.5. CALLED CONTEXT - 8.6.6. USERNAME - 8.6.8. CAPABILITY - 8.6.9. FORMAT - 8.6.10. LANGUAGE - 8.6.11. VERSION (MUST, and should be first) - 8.6.12. ADSICPE - 8.6.13. DNID - 8.6.25. AUTOANSWER - 8.6.31. DATETIME - 8.6.38. CALLINGPRES - 8.6.39. CALLINGTON - 8.6.43. ENCRYPTION - 8.6.45. CODEC PREFS */ public void sendNew( Character cno, String username, String calledNo, String callingNo, String callingName) { Log.debug( "ProtocolControlFrameNew.sendNew: calledNo=" + calledNo + ", callingNo=" + callingNo + ", callingName=" + callingName + ", username="******"foobar","724024"); Log.debug("Sending initial NEW"); sendMe(ie); }
/** * Returns a cyclified string representation of the given <tt>Object</tt>. Embedded constants are * prefixed with "#$". * * @return a <tt>String</tt> representation in cyclified form. */ public static String cyclify(Object obj) { if (obj == null) { throw new BaseClientRuntimeException("Cannot cyclify null obj"); } else if (!isCycLObject(obj)) { throw new BaseClientRuntimeException( "Cannot cyclify: '" + obj + "' (" + obj.getClass().getName() + ")."); } if (obj instanceof CycObject) { return ((CycObject) obj).cyclify(); } if (obj instanceof String) { return "\"" + (String) obj + "\""; } if (obj instanceof Character) { // @hack -- do better job of this. Need to support other non-printable characters!!! Character theChar = (Character) obj; if (theChar == ' ') { return "#\\Space"; } else if (theChar == '\n') { return "#\\Newline"; } else if (theChar == '\r') { return "#\\Return"; } else if (theChar == '\t') { return "#\\Tab"; } if (Character.isWhitespace(theChar)) { throw new IllegalArgumentException( "Don't know how to trasmit the whitespace character: " + (int) theChar.charValue()); } return "#\\" + obj; } return obj.toString(); }
public String getProblemCharacters() { StringBuilder chars = new StringBuilder(); for (Character ch : problemCharacters) { chars.append(ch.charValue()); } return chars.toString(); }
/** Output the specified character, both to the buffer and the output stream. */ private final void putChar(final int c, final boolean print) throws IOException { buf.write((char) c); if (print) { // no masking... if (mask == null) { printCharacter(c); } // null mask: don't print anything... else if (mask.charValue() == 0) {; } // otherwise print the mask... else { printCharacter(mask.charValue()); } drawBuffer(); } }
/** * Verifies the consistency of the parameters and throws an IllegalStateException if necessary. * * @throws IllegalStateException */ void validate() throws IllegalStateException { if (quoteChar != null && delimiter == quoteChar.charValue()) { throw new IllegalStateException( "The quoteChar character and the delimiter cannot be the same ('" + quoteChar + "')"); } if (escape != null && delimiter == escape.charValue()) { throw new IllegalStateException( "The escape character and the delimiter cannot be the same ('" + escape + "')"); } if (commentStart != null && delimiter == commentStart.charValue()) { throw new IllegalStateException( "The comment start character and the delimiter cannot be the same ('" + commentStart + "')"); } if (quoteChar != null && quoteChar.equals(commentStart)) { throw new IllegalStateException( "The comment start character and the quoteChar cannot be the same ('" + commentStart + "')"); } if (escape != null && escape.equals(commentStart)) { throw new IllegalStateException( "The comment start and the escape character cannot be the same ('" + commentStart + "')"); } if (escape == null && quotePolicy == Quote.NONE) { throw new IllegalStateException("No quotes mode set but no escape character is set"); } if (header != null) { final Set<String> set = new HashSet<String>(header.length); set.addAll(Arrays.asList(header)); if (set.size() != header.length) { throw new IllegalStateException( "The header contains duplicate names: " + Arrays.toString(header)); } } }
/** * Deal with formatting characters. * * <p>Parsing is as follows: - Treat all contiguous strings of formatting characters as one block. * (This method processes one block.) - Only a single instance of a particular format character * within a block is used to determine whether to turn on/off that type of formatting; other * instances simply print the character itself. - If the format is to be turned on, we use the * _first_ instance; if it is to be turned off, we use the _last_ instance (by appending the * format.) * * <p>Example: **string** turns into <b>*string*</b> */ private boolean parseFormatting() { if (!parseFormatting) { return false; } int endChar = nextChar; while ((endChar < text.length()) && isFormatChar(text.charAt(endChar))) { endChar += 1; } if ((endChar == nextChar) || !isWordBreak(endChar)) { return false; } // Keeps track of whether we've seen a character (in map if we've seen it) // and whether we should append a closing format token (if value in // map is TRUE). Linked hashmap for consistent ordering. LinkedHashMap<Character, Boolean> seenCharacters = new LinkedHashMap<Character, Boolean>(); for (int index = nextChar; index < endChar; ++index) { char ch = text.charAt(index); Character key = Character.valueOf(ch); if (seenCharacters.containsKey(key)) { // Already seen this character, just append an unmatched token, which // will print plaintext character addToken(new Format(ch, false)); } else { Format start = formatStart.get(key); if (start != null) { // Match the start token, and ask an end token to be appended start.setMatched(true); formatStart.remove(key); seenCharacters.put(key, Boolean.TRUE); } else { // Append start token start = new Format(ch, true); formatStart.put(key, start); addToken(start); seenCharacters.put(key, Boolean.FALSE); } } } // Append any necessary end tokens for (Character key : seenCharacters.keySet()) { if (seenCharacters.get(key) == Boolean.TRUE) { Format end = new Format(key.charValue(), false); end.setMatched(true); addToken(end); } } nextChar = endChar; return true; }
/** * Redraw the rest of the buffer from the cursor onwards. This is necessary for inserting text * into the buffer. * * @param clear the number of characters to clear after the end of the buffer */ private final void drawBuffer(final int clear) throws IOException { // debug ("drawBuffer: " + clear); char[] chars = buf.buffer.substring(buf.cursor).toCharArray(); if (mask != null) Arrays.fill(chars, mask.charValue()); printCharacters(chars); clearAhead(clear); back(chars.length); flushConsole(); }
// replaces whitespace char with replaceWhitespaceWith private char[] replaceWhiteSpace(char[] token) { char[] replaced = new char[token.length]; for (int i = 0; i < token.length; i++) { if (token[i] == ' ') { replaced[i] = replaceWhitespaceWith.charValue(); } else { replaced[i] = token[i]; } } return replaced; }
public VisualizeUnicodeNormalization() { super("HFS+ Unicode Decomposition Table"); JPanel mainPanel = new JPanel(); JScrollPane mainPanelScroller = new JScrollPane( mainPanel, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER); mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS)); mainPanelScroller.getVerticalScrollBar().setUnitIncrement(20); UnicodeNormalizationToolkit unt = UnicodeNormalizationToolkit.getDefaultInstance(); Map<Character, char[]> table = unt.getDecompositionTable(); StringBuilder sb = new StringBuilder(); Comparator<Map.Entry<Character, char[]>> cmp = new Comparator<Map.Entry<Character, char[]>>() { public int compare(Map.Entry<Character, char[]> o1, Map.Entry<Character, char[]> o2) { return o1.getKey().compareTo(o2.getKey()); } @Override public boolean equals(Object obj) { return super.equals(obj); } }; TreeSet<Map.Entry<Character, char[]>> ts = new TreeSet<Map.Entry<Character, char[]>>(cmp); for (Map.Entry<Character, char[]> ent : table.entrySet()) ts.add(ent); // ts.addAll(table.entrySet()); for (Map.Entry<Character, char[]> ent : ts) { Character key = ent.getKey(); char[] value = ent.getValue(); sb.append(Util.toHexStringBE(key.charValue())); sb.append(": \" "); sb.append(key.toString()); sb.append(" \" -> \" "); sb.append(value[0]); for (int i = 1; i < value.length; ++i) { sb.append(" \", \" "); sb.append(value[i]); } sb.append(" \""); JLabel cur = new JLabel(sb.toString()); cur.setFont(new java.awt.Font("Monospaced", 0, 20)); mainPanel.add(cur); sb.setLength(0); } add(mainPanelScroller, BorderLayout.CENTER); setDefaultCloseOperation(EXIT_ON_CLOSE); pack(); setLocationRelativeTo(null); }
/** * Decode an ANSEL byte into a UTF-16 Character * * @param b the ANSEL byte (in int form) * @return the character (in UTF-16) represented by the byte */ public static char decode(int b) { if (b < 0x80) { return (char) b; } Character result = byteToChar.get(Character.valueOf((char) b)); if (result == null) { // Map unmappable characters to a question mark return '?'; } return result.charValue(); }
@Nonnull private static String _getAsString(@Nonnull final Set<Character> aInvalidChars) { if (ContainerHelper.isEmpty(aInvalidChars)) return "NONE"; final StringBuilder aSB = new StringBuilder(); for (final Character aChar : aInvalidChars) { if (aSB.length() > 0) aSB.append(", "); final int nChar = aChar.charValue(); aSB.append("0x").append(StringHelper.getHexStringLeadingZero(nChar, 2)); } return aSB.toString(); }
private char[] fixWhitespace(char[] phrase) { if (replaceWhitespaceWith == null) return phrase; char[] fixed = new char[phrase.length]; for (int i = 0; i < phrase.length; i++) { if (phrase[i] == replaceWhitespaceWith.charValue()) { fixed[i] = ' '; } else { fixed[i] = phrase[i]; } } return fixed; }
/** * Encode a character for URLs * * @param immune characters not to encode * @param c character to encode * @return the encoded string representing c */ public String encodeCharacter(char[] immune, Character c) { String cStr = String.valueOf(c.charValue()); byte[] bytes; StringBuilder sb; if (UNENCODED_SET.contains(c)) return cStr; bytes = toUtf8Bytes(cStr); sb = new StringBuilder(bytes.length * 3); for (byte b : bytes) appendTwoUpperHex(sb.append('%'), b); return sb.toString(); }
public int findNearestPosition(Character c) { int pos = getCursor().getColumnIndex(StationDao.NAME); for (int i = 0; i < getCount(); i++) { Cursor cursor = (Cursor) getItem(i); String name = cursor.getString(pos); int cn = name.charAt(0); int cc = c.charValue(); if (cn == cc) { return i; } if (cn > cc) { return i; } } return 0; }
public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException { SerializeWriter out = serializer.getWriter(); Character value = (Character) object; if (value == null) { out.writeString(""); return; } char c = value.charValue(); if (c == 0) { out.writeString("\u0000"); } else { out.writeString(value.toString()); } }
public String tokenizeSymbolList(SymbolList sl) throws IllegalAlphabetException { if (sl.getAlphabet() != getAlphabet()) { throw new IllegalAlphabetException( "Alphabet " + sl.getAlphabet().getName() + " does not match " + getAlphabet().getName()); } StringBuffer sb = new StringBuffer(); for (Iterator i = sl.iterator(); i.hasNext(); ) { Symbol sym = (Symbol) i.next(); try { Character c = _tokenizeSymbol(sym); sb.append(c.charValue()); } catch (IllegalSymbolException ex) { throw new IllegalAlphabetException(ex, "Couldn't tokenize"); } } return sb.substring(0); }
/** * Translates an entity to a unicode character. * * @param name the name of the entity * @return the corresponding unicode character */ public static char decodeEntity(final String name) { if (name.startsWith("#x")) { try { return (char) Integer.parseInt(name.substring(2), 16); } catch (NumberFormatException nfe) { return '\0'; } } if (name.startsWith("#")) { try { return (char) Integer.parseInt(name.substring(1)); } catch (NumberFormatException nfe) { return '\0'; } } Character c = MAP.get(name); if (c == null) return '\0'; else return c.charValue(); }
public void test_Basics() { harness.check(!(Character.forDigit(8, 2) != '\0'), "test_forDigit - 50"); harness.check(!(Character.forDigit(-3, 2) != '\0'), "test_forDigit - 51"); harness.check(!(Character.forDigit(2, 8) != '2'), "test_forDigit - 52"); harness.check(!(Character.forDigit(12, 16) != 'c'), "test_forDigit - 53"); // sgurin // harness.check(!(Character.isJavaLetter('\uFFFF')), // "test_forDigit - 54"); // harness.check(!(!Character.isJavaLetter('a')), // "test_forDigit - 55"); harness.check(!(Character.MIN_VALUE != '\u0000'), "test_Basics - 1"); harness.check(!(Character.MAX_VALUE != '\uffff'), "test_Basics - 2"); harness.check(!(Character.MIN_RADIX != 2), "test_Basics - 3"); harness.check(!(Character.MAX_RADIX != 36), "test_Basics - 4"); Character ch = new Character('b'); harness.check(!(ch.charValue() != 'b'), "test_Basics - 5"); }
public String asCSV(Character separator, Character quotechar, Character endlinechar) { String csv = ""; if (separator == null) separator = ','; if (quotechar == null) quotechar = '"'; if (endlinechar == null) endlinechar = '\n'; try { if (this.headers != null && this.headers.size() > 0) { for (int i = 0; i < this.headers.size(); i++) { if (i != 0) csv += separator.charValue(); csv += quotechar + this.headers.get(i).getName() + quotechar; } csv += endlinechar; } else { logger.error("Table does not have any header."); } if (values == null) { logger.error("Table does not have any rows."); return csv; } for (int i = 0; i < this.values.size(); i++) { for (int j = 0; j < this.values.get(i).size(); j++) { if (j != 0) csv += separator; csv += quotechar + values.get(i).get(j) + quotechar; } csv += endlinechar; } return csv; } catch (Exception e) { logger.error("Error in generating CSV from the table."); e.printStackTrace(); return null; } }