public bool add(Object obj) { int size = map.size(); map.put(obj, dummyValue); return(map.size() != size); }
public OrderedProviderIterator(java.util.Iterator <Object> it) { // find all the nodes that with no incoming edges and // add them to firstNodes while (it.hasNext()) { ProviderNode node = (ProviderNode)it.next(); incomingEdges.put(node, new java.lang.Integer(node.getIncomingEdges())); if (node.getIncomingEdges() == 0) { firstNodes.push(node); } } }
/** * Adds a new element to the bag by incrementing its count in the map. * * @param object the object to search for * @param nCopies the number of copies to add * @return <code>true</code> if the object was not already in the <code>uniqueSet</code> */ public virtual bool add(Object obj, int nCopies) { _mods++; if (nCopies > 0) { int count = (nCopies + getCount(obj)); _map.put(obj, new java.lang.Integer(count)); _total += nCopies; return(count == nCopies); } else { return(false); } }
public void add(Token token, int docFreq) { if (tokenFrequency == null) { tokenFrequency = new LinkedHashMap/*<Token, Integer>*/ (); } tokenFrequency.put(token, docFreq); }
/** * This implementation uses an internal {@link HashMap} to map the name * to the specified object. * * @throws NullPointerException {@inheritDoc} */ public virtual Object setProperty(String name, Object value) { if (name == null) { throw new java.lang.NullPointerException("name is null"); } return(propMap.put(name, value)); }
/** * Sets the value associated with the key direct onto the map. * * @param value the new value * @return the old value * @throws IllegalArgumentException if the value is set to this map entry */ public Object setValue(Object value) { if (value == this) { throw new java.lang.IllegalArgumentException("Cannot set value to this map entry"); } return(map.put(key, value)); }
/** * This implementation uses an internal {@link HashMap} to map the URI * to the specified prefix. * * @throws NullPointerException {@inheritDoc} */ public virtual String putNamespacePrefix(String namespaceURI, String prefix) { if (namespaceURI == null) { throw new java.lang.NullPointerException("namespaceURI is null"); } return(nsMap.put(namespaceURI, prefix)); }
awt.FontMetrics GetMetrics(FontStyle style) { if ((_lastStyle != style) || (_fontMetrics == null)) { java.util.Map attrib = Font.DeriveStyle(FamilyFont.getAttributes(), style, true); attrib.put(TextAttribute.SIZE, new java.lang.Float((float)(UnitsPerEm << 1))); _fontMetrics = Container.getFontMetrics(FamilyFont.deriveFont(attrib)); } return(_fontMetrics); }
/** * Gets the <code>BeanInfo</code> object which contains the information of * the properties, events and methods of the specified bean class. * * <p> * The <code>Introspector</code> will cache the <code>BeanInfo</code> * object. Subsequent calls to this method will be answered with the cached * data. * </p> * * @param beanClass * the specified bean class. * @return the <code>BeanInfo</code> of the bean class. * @throws IntrospectionException */ public static BeanInfo getBeanInfo(java.lang.Class beanClass) {//throws IntrospectionException { StandardBeanInfo beanInfo = theCache.get(beanClass); if (beanInfo == null) { beanInfo = getBeanInfoImplAndInit(beanClass, null, USE_ALL_BEANINFO); theCache.put(beanClass, beanInfo); } return(beanInfo); }
public static Type GetTypeForJavaClass(java.lang.Class jclass) { if (jclass2type.containsKey(jclass)) { return((Type)jclass2type.get(jclass)); } Type t = new InternalTypes.InternalType(jclass); jclass2type.put(jclass, t); return(t); }
/** * Read the map in using a custom routine. * @param map the map to use * @param in the input stream * @throws IOException * @throws ClassNotFoundException */ protected virtual void doReadObject(java.util.Map <Object, Object> map, java.io.ObjectInputStream inJ) {// throws IOException, ClassNotFoundException { this.map = map; int entrySize = inJ.readInt(); for (int i = 0; i < entrySize; i++) { Object obj = inJ.readObject(); int count = inJ.readInt(); map.put(obj, new MutableInteger(count)); sizeJ += count; } }
/** * Puts a key-value mapping into the map at the specified index. * <p> * If the map already contains the key, then the original mapping * is removed and the new mapping added at the specified index. * The remove may change the effect of the index. The index is * always calculated relative to the original state of the map. * <p> * Thus the steps are: (1) remove the existing key-value mapping, * then (2) insert the new key-value mapping at the position it * would have been inserted had the remove not ocurred. * * @param index the index at which the mapping should be inserted * @param key the key * @param value the value * @return the value previously mapped to the key * @throws IndexOutOfBoundsException if the index is out of range * @since Commons Collections 3.2 */ public virtual Object put(int index, Object key, Object value) { java.util.Map <Object, Object> m = getMap(); if (m.containsKey(key)) { Object result = m.remove(key); int pos = insertOrder.indexOf(key); insertOrder.remove(pos); if (pos < index) { index--; } insertOrder.add(index, key); m.put(key, value); return(result); } else { insertOrder.add(index, key); m.put(key, value); return(null); } }
/** * Register a ZipExtraField implementation. * * <p>The given class must have a no-arg constructor and implement * the {@link ZipExtraField ZipExtraField interface}.</p> * @param c the class to register */ public static void register(Type c) { try { ZipExtraField ze = (ZipExtraField)Activator.CreateInstance(c); implementations.put(ze.getHeaderId(), c); } catch (InvalidCastException) { throw new java.lang.RuntimeException(c + " doesn\'t implement ZipExtraField"); } catch (MethodAccessException) { throw new java.lang.RuntimeException(c + "\'s no-arg constructor is not public"); } catch (MemberAccessException) { throw new java.lang.RuntimeException(c + " is not a concrete class"); } }
bool addProvider(Object provider) { ProviderNode node = new ProviderNode(provider); nodeMap.put(provider, node); Object obj = providers.put(provider.getClass(), provider); if (obj != null) { nodeMap.remove(obj); return(false); } return(true); }
/** * Applies a given attribute to this string. * * @param attribute * the attribute that will be applied to this string. * @param value * the value of the attribute that will be applied to this * string. * @throws IllegalArgumentException * if the length of this attributed string is 0. * @throws NullPointerException * if {@code attribute} is {@code null}. */ public void addAttribute(AttributedCharacterIteratorNS.Attribute attribute, System.Object value) { if (null == attribute) { throw new java.lang.NullPointerException(); } if (text.Length == 0) { throw new java.lang.IllegalArgumentException(); } java.util.List <IAC_Range> ranges = attributeMap.get(attribute); if (ranges == null) { ranges = new java.util.ArrayList <IAC_Range>(1); attributeMap.put(attribute, ranges); } else { ranges.clear(); } ranges.add(new IAC_Range(0, text.Length, value)); }
/** * Registers the element's attribute specified by the namespace URI and * local name to be of type ID. The attribute must have a non-empty value. * * <p>This implementation uses an internal {@link HashMap} to map the * attribute's value to the specified element. * * @param element the element * @param namespaceURI the namespace URI of the attribute (specify * <code>null</code> if not applicable) * @param localName the local name of the attribute * @throws IllegalArgumentException if <code>localName</code> is not an * attribute of the specified element or it does not contain a specific * value * @throws NullPointerException if <code>element</code> or * <code>localName</code> is <code>null</code> * @see #getElementById */ public void setIdAttributeNS(org.w3c.dom.Element element, String namespaceURI, String localName) { if (element == null) { throw new java.lang.NullPointerException("element is null"); } if (localName == null) { throw new java.lang.NullPointerException("localName is null"); } String idValue = element.getAttributeNS(namespaceURI, localName); if (idValue == null || idValue.length() == 0) { throw new java.lang.IllegalArgumentException(localName + " is not an " + "attribute"); } idMap.put(idValue, element); }
private void aggregateGroupDescs(java.util.Map <string, java.util.List <android.content.pm.PermissionInfo > > map, java.util.Map <string, string> retMap) { if (map == null) { return; } if (retMap == null) { return; } java.util.Set <string> grpNames = map.keySet(); java.util.Iterator <string> grpNamesIter = grpNames.iterator(); while (grpNamesIter.hasNext()) { string grpDesc = null; string grpNameKey = grpNamesIter.next(); java.util.List <android.content.pm.PermissionInfo> grpPermsList = map.get(grpNameKey ); if (grpPermsList == null) { continue; } foreach (android.content.pm.PermissionInfo permInfo in Sharpen.IterableProxy.Create (grpPermsList)) { java.lang.CharSequence permDesc = permInfo.loadLabel(mPm); grpDesc = formatPermissions(grpDesc, permDesc); } // Insert grpDesc into map if (grpDesc != null) { if (localLOGV) { android.util.Log.i(TAG, "Group:" + grpNameKey + " description:" + grpDesc.ToString ()); } retMap.put(grpNameKey, grpDesc.ToString()); } } }
/** * Adds a new element to the bag, incrementing its count in the map. * * @param object the object to search for * @param nCopies the number of copies to add * @return <code>true</code> if the object was not already in the <code>uniqueSet</code> */ public virtual bool add(Object obj, int nCopies) { modCount++; if (nCopies > 0) { MutableInteger mut = (MutableInteger)map.get(obj); sizeJ += nCopies; if (mut == null) { map.put(obj, new MutableInteger(nCopies)); return(true); } else { mut.value += nCopies; return(false); } } else { return(false); } }
/** * Creates an {@code AttributedString} from the given text and the * attributes. The whole text has the given attributes applied. * * @param value * the text to take as base for this attributed string. * @param attributes * the attributes that the text is associated with. * @throws IllegalArgumentException * if the length of {@code value} is 0 but the size of {@code * attributes} is greater than 0. * @throws NullPointerException * if {@code value} is {@code null}. */ public AttributedString(System.String value, java.util.Map <AttributedCharacterIteratorNS.Attribute, System.Object> attributes) { if (value == null) { throw new java.lang.NullPointerException(); } if (value.Length == 0 && !attributes.isEmpty()) { // text.0B=Cannot add attributes to empty string throw new java.lang.IllegalArgumentException("Cannot add attributes to empty string"); //$NON-NLS-1$ } text = value; attributeMap = new java.util.HashMap <AttributedCharacterIteratorNS.Attribute, java.util.List <IAC_Range> >();//(attributes.size() * 4 / 3) + 1); java.util.Iterator <java.util.MapNS.Entry <AttributedCharacterIteratorNS.Attribute, System.Object> > it = attributes.entrySet().iterator(); while (it.hasNext()) { java.util.MapNS.Entry <AttributedCharacterIteratorNS.Attribute, System.Object> entry = it.next(); java.util.ArrayList <IAC_Range> ranges = new java.util.ArrayList <IAC_Range>(1); ranges.add(new IAC_Range(0, text.Length, entry.getValue())); attributeMap.put((AttributedCharacterIteratorNS.Attribute)entry .getKey(), ranges); } }
/** * Creates an {@code AttributedString} from the given text and the * attributes. The whole text has the given attributes applied. * * @param value * the text to take as base for this attributed string. * @param attributes * the attributes that the text is associated with. * @throws IllegalArgumentException * if the length of {@code value} is 0 but the size of {@code * attributes} is greater than 0. * @throws NullPointerException * if {@code value} is {@code null}. */ public AttributedString(System.String value, java.util.Map<AttributedCharacterIteratorNS.Attribute, System.Object> attributes) { if (value == null) { throw new java.lang.NullPointerException(); } if (value.Length == 0 && !attributes.isEmpty()) { // text.0B=Cannot add attributes to empty string throw new java.lang.IllegalArgumentException("Cannot add attributes to empty string"); //$NON-NLS-1$ } text = value; attributeMap = new java.util.HashMap<AttributedCharacterIteratorNS.Attribute, java.util.List<IAC_Range>>();//(attributes.size() * 4 / 3) + 1); java.util.Iterator<java.util.MapNS.Entry<AttributedCharacterIteratorNS.Attribute,System.Object>> it = attributes.entrySet().iterator(); while (it.hasNext()) { java.util.MapNS.Entry<AttributedCharacterIteratorNS.Attribute, System.Object> entry = it.next(); java.util.ArrayList<IAC_Range> ranges = new java.util.ArrayList<IAC_Range>(1); ranges.add(new IAC_Range(0, text.Length, entry.getValue())); attributeMap.put((AttributedCharacterIteratorNS.Attribute) entry .getKey(), ranges); } }
/** * Reads the central directory of the given archive and populates * the internal tables with ZipArchiveEntry instances. * * <p>The ZipArchiveEntrys will know all data that can be obtained from * the central directory alone, but not the data that requires the * local file header or additional data to be read.</p> * * @return a Map<ZipArchiveEntry, NameAndComment>> of * zipentries that didn't have the language encoding flag set when * read. */ private java.util.Map <ZipArchiveEntry, IAC_NameAndComment> populateFromCentralDirectory() //throws IOException { java.util.HashMap <ZipArchiveEntry, IAC_NameAndComment> noUTF8Flag = new java.util.HashMap <ZipArchiveEntry, IAC_NameAndComment>(); positionAtCentralDirectory(); byte[] cfh = new byte[CFH_LEN]; byte[] signatureBytes = new byte[WORD]; archive.readFully(signatureBytes); long sig = ZipLong.getValue(signatureBytes); long cfhSig = ZipLong.getValue(ZipArchiveOutputStream.CFH_SIG); if (sig != cfhSig && startsWithLocalFileHeader()) { throw new java.io.IOException("central directory is empty, can't expand" + " corrupt archive."); } while (sig == cfhSig) { archive.readFully(cfh); int off = 0; ZipArchiveEntry ze = new ZipArchiveEntry(); int versionMadeBy = ZipShort.getValue(cfh, off); off += SHORT; ze.setPlatform((versionMadeBy >> BYTE_SHIFT) & NIBLET_MASK); off += SHORT; // skip version info GeneralPurposeBit gpFlag = GeneralPurposeBit.parse(cfh, off); bool hasUTF8Flag = gpFlag.usesUTF8ForNames(); ZipEncoding entryEncoding = hasUTF8Flag ? ZipEncodingHelper.UTF8_ZIP_ENCODING : zipEncoding; ze.setGeneralPurposeBit(gpFlag); off += SHORT; ze.setMethod(ZipShort.getValue(cfh, off)); off += SHORT; // FIXME this is actually not very cpu cycles friendly as we are converting from // dos to java while the underlying Sun implementation will convert // from java to dos time for internal storage... long time = ZipUtil.dosToJavaTime(ZipLong.getValue(cfh, off)); ze.setTime(time); off += WORD; ze.setCrc(ZipLong.getValue(cfh, off)); off += WORD; ze.setCompressedSize(ZipLong.getValue(cfh, off)); off += WORD; ze.setSize(ZipLong.getValue(cfh, off)); off += WORD; int fileNameLen = ZipShort.getValue(cfh, off); off += SHORT; int extraLen = ZipShort.getValue(cfh, off); off += SHORT; int commentLen = ZipShort.getValue(cfh, off); off += SHORT; off += SHORT; // disk number ze.setInternalAttributes(ZipShort.getValue(cfh, off)); off += SHORT; ze.setExternalAttributes(ZipLong.getValue(cfh, off)); off += WORD; byte[] fileName = new byte[fileNameLen]; archive.readFully(fileName); ze.setName(entryEncoding.decode(fileName)); // LFH offset, IAC_OffsetEntry offset = new IAC_OffsetEntry(); offset.headerOffset = ZipLong.getValue(cfh, off); // data offset will be filled later entries.put(ze, offset); nameMap.put(ze.getName(), ze); byte[] cdExtraData = new byte[extraLen]; archive.readFully(cdExtraData); ze.setCentralDirectoryExtra(cdExtraData); byte[] comment = new byte[commentLen]; archive.readFully(comment); ze.setComment(entryEncoding.decode(comment)); archive.readFully(signatureBytes); sig = ZipLong.getValue(signatureBytes); if (!hasUTF8Flag && useUnicodeExtraFields) { noUTF8Flag.put(ze, new IAC_NameAndComment(fileName, comment)); } } return(noUTF8Flag); }
private void setPermissions(java.util.List <android.content.pm.PermissionInfo> permList ) { mGroupLabelCache = new java.util.HashMap <string, java.lang.CharSequence>(); //add the default label so that uncategorized permissions can go here mGroupLabelCache.put(mDefaultGrpName, java.lang.CharSequenceProxy.Wrap(mDefaultGrpLabel )); // Map containing group names and a list of permissions under that group // categorized as dangerous mDangerousMap = new java.util.HashMap <string, string>(); // Map containing group names and a list of permissions under that group // categorized as normal mNormalMap = new java.util.HashMap <string, string>(); // Additional structures needed to ensure that permissions are unique under // each group java.util.Map <string, java.util.List <android.content.pm.PermissionInfo> > dangerousMap = new java.util.HashMap <string, java.util.List <android.content.pm.PermissionInfo > >(); java.util.Map <string, java.util.List <android.content.pm.PermissionInfo> > normalMap = new java.util.HashMap <string, java.util.List <android.content.pm.PermissionInfo > >(); android.widget.AppSecurityPermissions.PermissionInfoComparator permComparator = new android.widget.AppSecurityPermissions.PermissionInfoComparator(mPm); if (permList != null) { // First pass to group permissions foreach (android.content.pm.PermissionInfo pInfo in Sharpen.IterableProxy.Create( permList)) { if (localLOGV) { android.util.Log.i(TAG, "Processing permission:" + pInfo.name); } if (!isDisplayablePermission(pInfo)) { if (localLOGV) { android.util.Log.i(TAG, "Permission:" + pInfo.name + " is not displayable"); } continue; } java.util.Map <string, java.util.List <android.content.pm.PermissionInfo> > permInfoMap = (pInfo.protectionLevel == android.content.pm.PermissionInfo.PROTECTION_DANGEROUS ) ? dangerousMap : normalMap; string grpName = (pInfo.group == null) ? mDefaultGrpName : pInfo.group; if (localLOGV) { android.util.Log.i(TAG, "Permission:" + pInfo.name + " belongs to group:" + grpName ); } java.util.List <android.content.pm.PermissionInfo> grpPermsList = permInfoMap.get( grpName); if (grpPermsList == null) { grpPermsList = new java.util.ArrayList <android.content.pm.PermissionInfo>(); permInfoMap.put(grpName, grpPermsList); grpPermsList.add(pInfo); } else { int idx = java.util.Collections.binarySearch(grpPermsList, pInfo, permComparator); if (localLOGV) { android.util.Log.i(TAG, "idx=" + idx + ", list.size=" + grpPermsList.size()); } if (idx < 0) { idx = -idx - 1; grpPermsList.add(idx, pInfo); } } } // Second pass to actually form the descriptions // Look at dangerous permissions first aggregateGroupDescs(dangerousMap, mDangerousMap); aggregateGroupDescs(normalMap, mNormalMap); } mCurrentState = android.widget.AppSecurityPermissions.State.NO_PERMS; if (mDangerousMap.size() > 0) { mCurrentState = (mNormalMap.size() > 0) ? android.widget.AppSecurityPermissions.State .BOTH : android.widget.AppSecurityPermissions.State.DANGEROUS_ONLY; } else { if (mNormalMap.size() > 0) { mCurrentState = android.widget.AppSecurityPermissions.State.NORMAL_ONLY; } } if (localLOGV) { android.util.Log.i(TAG, "mCurrentState=" + mCurrentState); } showPermissions(); }
internal void addCategory(java.lang.Class category) { categories.put(category, new ProvidersMap()); }
/** * Writes the local file header entry * @param ze the entry to write * @throws IOException on error */ protected void writeLocalFileHeader(ZipArchiveEntry ze) //throws IOException { bool encodable = zipEncoding.canEncode(ze.getName()); ZipEncoding entryEncoding; if (!encodable && fallbackToUTF8) { entryEncoding = ZipEncodingHelper.UTF8_ZIP_ENCODING; } else { entryEncoding = zipEncoding; } java.nio.ByteBuffer name = entryEncoding.encode(ze.getName()); if (createUnicodeExtraFields != UnicodeExtraFieldPolicy.NEVER) { if (createUnicodeExtraFields == UnicodeExtraFieldPolicy.ALWAYS || !encodable) { ze.addExtraField(new UnicodePathExtraField(ze.getName(), (byte[])name.array(), name.arrayOffset(), name.limit())); } String comm = ze.getComment(); if (comm != null && !"".equals(comm)) { bool commentEncodable = this.zipEncoding.canEncode(comm); if (createUnicodeExtraFields == UnicodeExtraFieldPolicy.ALWAYS || !commentEncodable) { java.nio.ByteBuffer commentB = entryEncoding.encode(comm); ze.addExtraField(new UnicodeCommentExtraField(comm, (byte[])commentB.array(), commentB.arrayOffset(), commentB.limit()) ); } } } offsets.put(ze, ZipLong.getBytes(written)); writeOut(LFH_SIG); written += WORD; //store method in local variable to prevent multiple method calls int zipMethod = ze.getMethod(); writeVersionNeededToExtractAndGeneralPurposeBits(zipMethod, !encodable && fallbackToUTF8); written += WORD; // compression method writeOut(ZipShort.getBytes(zipMethod)); written += SHORT; // last mod. time and date writeOut(ZipUtil.toDosTime(ze.getTime())); written += WORD; // CRC // compressed length // uncompressed length localDataStart = written; if (zipMethod == DEFLATED || raf != null) { writeOut(LZERO); writeOut(LZERO); writeOut(LZERO); } else { writeOut(ZipLong.getBytes(ze.getCrc())); writeOut(ZipLong.getBytes(ze.getSize())); writeOut(ZipLong.getBytes(ze.getSize())); } // CheckStyle:MagicNumber OFF written += 12; // CheckStyle:MagicNumber ON // file name length writeOut(ZipShort.getBytes(name.limit())); written += SHORT; // extra field length byte[] extra = ze.getLocalFileDataExtra(); writeOut(ZipShort.getBytes(extra.Length)); written += SHORT; // file name writeOut((byte[])name.array(), name.arrayOffset(), name.limit()); written += name.limit(); // extra field writeOut(extra); written += extra.Length; dataStart = written; }
protected TextAttribute(String name) : base(name) { attrMap.put(name, this); }
public virtual Object put(Object key, Object value) { return(map.put(key, value)); }
static ZipEncodingHelper() { simpleEncodings = new java.util.HashMap <String, SimpleEncodingHolder>(); char[] cp437_high_chars = new char[] { '\u00c7', '\u00fc', '\u00e9', '\u00e2', '\u00e4', '\u00e0', '\u00e5', '\u00e7', '\u00ea', '\u00eb', '\u00e8', '\u00ef', '\u00ee', '\u00ec', '\u00c4', '\u00c5', '\u00c9', '\u00e6', '\u00c6', '\u00f4', '\u00f6', '\u00f2', '\u00fb', '\u00f9', '\u00ff', '\u00d6', '\u00dc', '\u00a2', '\u00a3', '\u00a5', '\u20a7', '\u0192', '\u00e1', '\u00ed', '\u00f3', '\u00fa', '\u00f1', '\u00d1', '\u00aa', '\u00ba', '\u00bf', '\u2310', '\u00ac', '\u00bd', '\u00bc', '\u00a1', '\u00ab', '\u00bb', '\u2591', '\u2592', '\u2593', '\u2502', '\u2524', '\u2561', '\u2562', '\u2556', '\u2555', '\u2563', '\u2551', '\u2557', '\u255d', '\u255c', '\u255b', '\u2510', '\u2514', '\u2534', '\u252c', '\u251c', '\u2500', '\u253c', '\u255e', '\u255f', '\u255a', '\u2554', '\u2569', '\u2566', '\u2560', '\u2550', '\u256c', '\u2567', '\u2568', '\u2564', '\u2565', '\u2559', '\u2558', '\u2552', '\u2553', '\u256b', '\u256a', '\u2518', '\u250c', '\u2588', '\u2584', '\u258c', '\u2590', '\u2580', '\u03b1', '\u00df', '\u0393', '\u03c0', '\u03a3', '\u03c3', '\u00b5', '\u03c4', '\u03a6', '\u0398', '\u03a9', '\u03b4', '\u221e', '\u03c6', '\u03b5', '\u2229', '\u2261', '\u00b1', '\u2265', '\u2264', '\u2320', '\u2321', '\u00f7', '\u2248', '\u00b0', '\u2219', '\u00b7', '\u221a', '\u207f', '\u00b2', '\u25a0', '\u00a0' }; SimpleEncodingHolder cp437 = new SimpleEncodingHolder(cp437_high_chars); simpleEncodings.put("CP437", cp437); simpleEncodings.put("Cp437", cp437); simpleEncodings.put("cp437", cp437); simpleEncodings.put("IBM437", cp437); simpleEncodings.put("ibm437", cp437); char[] cp850_high_chars = new char[] { '\u00c7', '\u00fc', '\u00e9', '\u00e2', '\u00e4', '\u00e0', '\u00e5', '\u00e7', '\u00ea', '\u00eb', '\u00e8', '\u00ef', '\u00ee', '\u00ec', '\u00c4', '\u00c5', '\u00c9', '\u00e6', '\u00c6', '\u00f4', '\u00f6', '\u00f2', '\u00fb', '\u00f9', '\u00ff', '\u00d6', '\u00dc', '\u00f8', '\u00a3', '\u00d8', '\u00d7', '\u0192', '\u00e1', '\u00ed', '\u00f3', '\u00fa', '\u00f1', '\u00d1', '\u00aa', '\u00ba', '\u00bf', '\u00ae', '\u00ac', '\u00bd', '\u00bc', '\u00a1', '\u00ab', '\u00bb', '\u2591', '\u2592', '\u2593', '\u2502', '\u2524', '\u00c1', '\u00c2', '\u00c0', '\u00a9', '\u2563', '\u2551', '\u2557', '\u255d', '\u00a2', '\u00a5', '\u2510', '\u2514', '\u2534', '\u252c', '\u251c', '\u2500', '\u253c', '\u00e3', '\u00c3', '\u255a', '\u2554', '\u2569', '\u2566', '\u2560', '\u2550', '\u256c', '\u00a4', '\u00f0', '\u00d0', '\u00ca', '\u00cb', '\u00c8', '\u0131', '\u00cd', '\u00ce', '\u00cf', '\u2518', '\u250c', '\u2588', '\u2584', '\u00a6', '\u00cc', '\u2580', '\u00d3', '\u00df', '\u00d4', '\u00d2', '\u00f5', '\u00d5', '\u00b5', '\u00fe', '\u00de', '\u00da', '\u00db', '\u00d9', '\u00fd', '\u00dd', '\u00af', '\u00b4', '\u00ad', '\u00b1', '\u2017', '\u00be', '\u00b6', '\u00a7', '\u00f7', '\u00b8', '\u00b0', '\u00a8', '\u00b7', '\u00b9', '\u00b3', '\u00b2', '\u25a0', '\u00a0' }; SimpleEncodingHolder cp850 = new SimpleEncodingHolder(cp850_high_chars); simpleEncodings.put("CP850", cp850); simpleEncodings.put("Cp850", cp850); simpleEncodings.put("cp850", cp850); simpleEncodings.put("IBM850", cp850); simpleEncodings.put("ibm850", cp850); }