/**
  * Temporarily disables auto-compaction. MUST be followed by calling {@link
  * #reenableAutoCompaction}.
  *
  * @see gnu.trove.impl.hash.THash#tempDisableAutoCompaction()
  */
 public void tempDisableAutoCompaction() {
   try {
     lock.xlock();
     cache.tempDisableAutoCompaction();
   } finally {
     lock.xunlock();
   }
 }
 /**
  * Re-enable auto-compaction after it was disabled via {@link #tempDisableAutoCompaction()}.
  *
  * @param check_for_compaction True if compaction should be performed if needed before returning.
  *     If false, no compaction will be performed.
  * @see gnu.trove.impl.hash.THash#reenableAutoCompaction(boolean)
  */
 public void reenableAutoCompaction(boolean check_for_compaction) {
   try {
     lock.xlock();
     cache.reenableAutoCompaction(check_for_compaction);
   } finally {
     lock.xunlock();
   }
 }
 /**
  * The auto-compaction factor controls whether and when a table performs a compaction
  * automatically after a certain number of remove operations. If the value is non-zero, the number
  * of removes that need to occur for auto-compaction is the size of table at the time of the
  * previous compaction (or the initial capacity) multiplied by this factor.
  *
  * <p>Setting this value to zero will disable auto-compaction.
  *
  * @param factor a <tt>float</tt> that indicates the auto-compaction factor
  * @see gnu.trove.impl.hash.THash#setAutoCompactionFactor(float)
  */
 public void setAutoCompactionFactor(float factor) {
   try {
     lock.xlock();
     cache.setAutoCompactionFactor(factor);
   } finally {
     lock.xunlock();
   }
 }
 /**
  * Returns the cache's auto compaction factor
  *
  * @return a <<tt>float</tt> that represents the auto-compaction factor.
  * @see gnu.trove.impl.hash.THash#getAutoCompactionFactor()
  */
 public float getAutoCompactionFactor() {
   try {
     lock.xlock();
     return cache.getAutoCompactionFactor();
   } finally {
     lock.xunlock();
   }
 }
 /**
  * Compresses the cache to the minimum prime size
  *
  * @see gnu.trove.impl.hash.THash#trimToSize()
  */
 public final void trimToSize() {
   try {
     lock.xlock();
     cache.trimToSize();
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#size()
  */
 @Override
 public int size() {
   try {
     lock.xlock();
     return cache.size();
   } finally {
     lock.xunlock();
   }
 }
 /**
  * Adjusts the primitive value mapped to the key if the key is present in the map.
  *
  * @param key The stringy key
  * @param value The value
  * @return true if a mapping was found and modified.
  * @see gnu.trove.map.hash.TObjectLongHashMap#adjustValue(java.lang.Object, long)
  */
 public boolean adjustValue(CharSequence key, long value) {
   if (key == null) throw new IllegalArgumentException("The passed key was null");
   try {
     lock.xlock();
     return cache.adjustValue(wrap(key), value);
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#clear()
  */
 @Override
 public void clear() {
   try {
     lock.xlock();
     cache.clear();
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#remove(java.lang.CharSequence)
  */
 @Override
 public long remove(CharSequence key) {
   if (key == null) throw new IllegalArgumentException("The passed key was null");
   try {
     lock.xlock();
     return cache.remove(wrap(key));
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#putIfAbsent(java.lang.CharSequence,
  *     long)
  */
 @Override
 public long putIfAbsent(CharSequence key, long value) {
   if (key == null) throw new IllegalArgumentException("The passed key was null");
   try {
     lock.xlock();
     return cache.putIfAbsent(wrap(key), value);
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IKeyCache#purge()
  */
 @Override
 public void purge() {
   try {
     lock.xlock();
     cache.clear();
     cache.trimToSize();
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#get(java.lang.CharSequence)
  */
 @Override
 public long get(CharSequence key) {
   if (key == null) return NO_ENTRY_VALUE;
   try {
     lock.xlock();
     if (cache.isEmpty()) return NO_ENTRY_VALUE;
     return cache.get(wrap(key));
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#containsKey(java.lang.CharSequence)
  */
 @Override
 public boolean containsKey(CharSequence key) {
   if (key == null) return false;
   try {
     lock.xlock();
     if (cache.isEmpty()) return false;
     return cache.containsKey(wrap(key));
   } finally {
     lock.xunlock();
   }
 }
 /**
  * {@inheritDoc}
  *
  * @see org.helios.rindle.store.chronicle.IStringKeyCache#putAll(java.util.Map)
  */
 @Override
 public void putAll(Map<? extends CharSequence, ? extends Long> map) {
   if (map == null) throw new IllegalArgumentException("The passed map was null");
   if (map.isEmpty()) return;
   try {
     lock.xlock();
     for (Map.Entry<? extends CharSequence, ? extends Long> entry : map.entrySet()) {
       _put(entry.getKey(), entry.getValue().longValue());
     }
   } finally {
     lock.xunlock();
   }
 }