/*
* Indicates whether or not the specified class is a dynamically generated
* proxy class.
*
* @param cl
* the class
* @return {@code true} if the class is a proxy class, {@code false}
* otherwise
* @throws NullPointerException
* if the class is {@code null}
*/
public static bool isProxyClass(Class cl)
{
if (cl == null)
{
throw new NullPointerException();
}
lock (proxyCache) {
return(proxyCache.containsKey(cl));
}
}
public override void putAll(java.util.Map <Object, Object> mapToCopy)
{
for (java.util.Iterator <Object> it = mapToCopy.keySet().iterator(); it.hasNext();)
{
if (mapToCopy.containsKey(it.next()) == false)
{
throw new java.lang.IllegalArgumentException("Cannot put new key/value pair - Map is fixed size");
}
}
map.putAll(mapToCopy);
}
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);
}
/**
* Walks through all recorded entries and adds the data available
* from the local file header.
*
* <p>Also records the offsets for the data to read from the
* entries.</p>
*/
private void resolveLocalFileHeaderData(java.util.Map <ZipArchiveEntry, IAC_NameAndComment> entriesWithoutUTF8Flag)
//throws IOException
{
java.util.Enumeration <ZipArchiveEntry> e = getEntries();
while (e.hasMoreElements())
{
ZipArchiveEntry ze = e.nextElement();
IAC_OffsetEntry offsetEntry = entries.get(ze);
long offset = offsetEntry.headerOffset;
archive.seek(offset + LFH_OFFSET_FOR_FILENAME_LENGTH);
byte[] b = new byte[SHORT];
archive.readFully(b);
int fileNameLen = ZipShort.getValue(b);
archive.readFully(b);
int extraFieldLen = ZipShort.getValue(b);
int lenToSkip = fileNameLen;
while (lenToSkip > 0)
{
int skipped = archive.skipBytes(lenToSkip);
if (skipped <= 0)
{
throw new java.lang.RuntimeException("failed to skip file name in"
+ " local file header");
}
lenToSkip -= skipped;
}
byte[] localExtraData = new byte[extraFieldLen];
archive.readFully(localExtraData);
ze.setExtra(localExtraData);
/*dataOffsets.put(ze,
* new Long(offset + LFH_OFFSET_FOR_FILENAME_LENGTH
+ SHORT + SHORT + fileNameLen + extraFieldLen));
*/
offsetEntry.dataOffset = offset + LFH_OFFSET_FOR_FILENAME_LENGTH
+ SHORT + SHORT + fileNameLen + extraFieldLen;
if (entriesWithoutUTF8Flag.containsKey(ze))
{
String orig = ze.getName();
IAC_NameAndComment nc = (IAC_NameAndComment)entriesWithoutUTF8Flag.get(ze);
ZipUtil.setNameAndCommentFromExtraFields(ze, nc.name, nc.comment);
if (!orig.equals(ze.getName()))
{
nameMap.remove(orig);
nameMap.put(ze.getName(), ze);
}
}
}
}
/**
* 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);
}
}
public virtual bool containsKey(Object key)
{
return(map.containsKey(key));
}
//-----------------------------------------------------------------------
/**
* Determines if the bag contains the given element by checking if the
* underlying map contains the element as a key.
*
* @param object the object to search for
* @return true if the bag contains the given element
*/
public virtual bool contains(Object obj)
{
return(map.containsKey(obj));
}
// Basic object methods
// ----------------------------------------------------------------------
/**
* Compare the specified object with this list for equality. This
* implementation uses exactly the code that is used to define the
* list equals function in the documentation for the
* <code>Map.equals</code> method.
*
* @param o the object to be compared to this list
* @return true if the two maps are equal
*/
public override bool Equals(Object o)
{
// Simple tests that require no synchronization
if (o == this)
{
return(true);
}
else if (!(o is java.util.Map <Object, Object>))
{
return(false);
}
java.util.Map <Object, Object> mo = (java.util.Map <Object, Object>)o;
// Compare the two maps for equality
if (fast)
{
if (mo.size() != map.size())
{
return(false);
}
java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator();
while (i.hasNext())
{
java.util.MapNS.Entry <Object, Object> e = i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null)
{
if (!(mo.get(key) == null && mo.containsKey(key)))
{
return(false);
}
}
else
{
if (!value.equals(mo.get(key)))
{
return(false);
}
}
}
return(true);
}
else
{
lock (map)
{
if (mo.size() != map.size())
{
return(false);
}
java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator();
while (i.hasNext())
{
java.util.MapNS.Entry <Object, Object> e = i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null)
{
if (!(mo.get(key) == null && mo.containsKey(key)))
{
return(false);
}
}
else
{
if (!value.equals(mo.get(key)))
{
return(false);
}
}
}
return(true);
}
}
}