/*

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.classscan.util;

 import java.lang.ref.Reference;

 import java.lang.ref.ReferenceQueue;

 import java.lang.ref.WeakReference;

 import java.util.Collection;

 import java.util.Map;

 import java.util.Set;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.ConcurrentMap;

 public final class ReapingHashMap<K, V> implements Map<K, V> {

     private final ConcurrentMap<HashWeakReference<K>, V> innerMap = new ConcurrentHashMap<HashWeakReference<K>, V>();

     private final ReferenceQueue<K> queue = new ReferenceQueue<K>();

     private final Thread reaper = new ReaperThread();

     public ReapingHashMap() {

         reaper.setDaemon(true);

         reaper.start();

     }

     private class ReaperThread extends Thread {

         ReaperThread() {

             super("WeakConcurrentHashMap-" + System.identityHashCode(ReapingHashMap.this) + "-reaper");

         }

         @Override

         public void run() {

             for (;;) {

                 try {

                     Reference<? extends K> ref = queue.remove();

                     HashWeakReference<? extends K> key = (HashWeakReference<? extends K>) ref;

                     innerMap.remove(key);

                 }

                 catch (InterruptedException ignore) {

                 }

             }

         }

     }

     @Override

     public V put(K key, V value) {

         HashWeakReference<K> innerKey = new HashWeakReference<K>(key, queue);

         return innerMap.put(innerKey, value);

     }

     @Override

     public V get(Object key) {

         KeyReference<Object> innerKey = new KeyReference<Object>(key);

         return innerMap.get(innerKey);

     }

     @Override

     public void clear() {

         throw new UnsupportedOperationException();

     }

     @Override

     public boolean containsKey(Object key) {

         throw new UnsupportedOperationException();

     }

     @Override

     public boolean containsValue(Object value) {

         throw new UnsupportedOperationException();

     }

     @Override

     public Set<Map.Entry<K, V>> entrySet() {

         throw new UnsupportedOperationException();

     }

     @Override

     public boolean isEmpty() {

         throw new UnsupportedOperationException();

     }

     @Override

     public Set<K> keySet() {

         throw new UnsupportedOperationException();

     }

     @Override

     public void putAll(Map<? extends K, ? extends V> m) {

         throw new UnsupportedOperationException();

     }

     @Override

     public V remove(Object key) {

         throw new UnsupportedOperationException();

     }

     @Override

     public int size() {

         throw new UnsupportedOperationException();

     }

     @Override

     public Collection<V> values() {

         throw new UnsupportedOperationException();

     }

     static class HashWeakReference<T> extends WeakReference<T> {

         private final int hashCode;

         HashWeakReference(T referent, ReferenceQueue<? super T> queue) {

             super(referent, queue);

             hashCode = System.identityHashCode(referent);

         }

         @Override

         public int hashCode() {

             return hashCode;

         }

         @Override

         public boolean equals(Object obj) {

                 if(this==obj) {

                         return true;

                 }

                 if(obj instanceof KeyReference) {

                         @SuppressWarnings("unchecked")

                             KeyReference<T> key= (KeyReference<T>)obj;

                         return key.compare(this);

                 }

                 throw new UnsupportedOperationException(obj.getClass().getCanonicalName());

         }

     }

     static class KeyReference<T> {

             private final T key;

             private final int keyHash;

             public KeyReference(T key) {

                     this.key= key;

                     keyHash= System.identityHashCode(key);

             }

             @Override

             public int hashCode() {

                     return keyHash;

             }

             /**

              * HashMap should only compare KeyReference with HashWeakReference

              */

             @Override

             public boolean equals(Object obj) {

                     if(obj instanceof  HashWeakReference) {

                             @SuppressWarnings("unchecked")

                             HashWeakReference<T> weakKey = (HashWeakReference<T>)obj;

                             return compare(weakKey);

                     }

                 throw new UnsupportedOperationException(obj.getClass().getCanonicalName());

             }

         boolean compare(HashWeakReference<T> ref) {        

                 T t = ref.get();

                     return key==t;

         }

     }

 }