public OrderedSet() { map = new OrderedMap<E, E>(); }
@Override public E put(String key, E value) { return super.put(key, value); }
public boolean containsKey(String key) { boolean result = super.containsKey(key); if (result) return result; for (String tmp : super.keySet()) if (tmp.equalsIgnoreCase(key)) return true; return result; }
public Map.Entry<K, V> getEntry(K key) { if (containsKey(key)) return new MapEntry<K, V>(key, get(key)); else return null; }
" FROM USER_OBJECTS WHERE UPPER(OBJECT_TYPE) = 'PACKAGE'"; List<Object[]> pkgInfos = DBUtil.query(query, connection); OrderedMap<String, DBPackage> packages = new OrderedMap<String, DBPackage>(); for (int i = 0; i < pkgInfos.size(); i++) { Object[] pkgInfo = pkgInfos.get(i); pkg.setObjectType((String) pkgInfo[4]); pkg.setStatus((String) pkgInfo[5]); packages.put(pkg.getName(), pkg); LOGGER.debug("Imported package {}", pkg); " FROM SYS.USER_PROCEDURES WHERE UPPER(OBJECT_TYPE) = 'PACKAGE'" + " AND PROCEDURE_NAME IS NOT NULL AND OBJECT_NAME IN (" + CollectionUtil.formatCommaSeparatedList(NameUtil.getNames(packages.values()), '\'') + ")"; List<Object[]> procInfos = DBUtil.query(query, connection); for (int i = 0; i < procInfos.size(); i++) { Object[] procInfo = procInfos.get(i); DBPackage owner = packages.get((String) procInfo[0]); String name = (String) procInfo[1]; DBProcedure proc = new DBProcedure(name, owner); LOGGER.debug("Imported package procedure {}.{}", owner.getName(), proc.getName()); return packages.values();
public boolean equalsIgnoreOrder(Map<K, V> that) { if (this == that) return true; if (this.size() != that.size()) return false; for (Map.Entry<K, V> entry : that.entrySet()) { K key = entry.getKey(); if (!this.containsKey(key)) return false; if (!NullSafeComparator.equals(this.get(key), that.get(key))) return false; } return true; }
public E get(String key) { return super.get(normalizeKey(key)); }
@Override public List<E> values() { return realMap.values(); }
@Override public boolean containsAll(Collection<?> items) { for (Object o : items) if (!map.containsKey(o)) return false; return true; }
private Converter findPoorConfiguredMatch(Class<?> srcType, Class dstType) { if (srcType == dstType || (dstType.isAssignableFrom(srcType) && !dstType.isPrimitive())) return new NoOpConverter(); for (Map.Entry<ConversionTypes, Class<? extends Converter>> entry : configuredConverterClasses.entrySet()) { ConversionTypes types = entry.getKey(); if (types.sourceType == srcType && dstType.isAssignableFrom(types.targetType)) return BeanUtil.newInstance(entry.getValue()); } return null; }
@Override public void clear() { map.clear(); }
@Override public Map.Entry<String, E> getEntry(String key) { String normalizedKey = normalizeKey(key); E value = super.get(normalizedKey); return new MapEntry<String, E>(normalizedKey, value); }
@Override public boolean contains(Object item) { return map.containsKey(item); }
@Override public String toString() { ListBasedSet<Entry<K, V>> entries = (ListBasedSet<Entry<K, V>>)entrySet(); StringBuilder buffer = new StringBuilder("{"); if (entries.size() > 0) buffer.append(entries.get(0)); for (int i = 1; i < entries.size(); i++) buffer.append(", ").append(entries.get(i)); buffer.append('}'); return buffer.toString(); }
public OrderedSet(int initialCapacity) { map = new OrderedMap<E, E>(initialCapacity); }
@Override public boolean add(E item) { return (map.put(item, item) == null); }
@Override public Map.Entry<String, E> getEntry(String key) { String normalizedKey = key; E value = super.get(normalizedKey); if (value != null) return new MapEntry<String, E>(key, value); for (Map.Entry<String, E> entry : super.entrySet()) { String tmp = entry.getKey(); if ((tmp == null && key == null) || (tmp != null && tmp.equalsIgnoreCase(key))) { String resultKey = entry.getKey(); return new MapEntry<String, E>(resultKey, entry.getValue()); } } return null; }
public boolean containsKey(String key) { return super.containsKey(normalizeKey(key)); }