All Downloads are FREE. Search and download functionalities are using the official Maven repository.

scouter.util.LinkedMap Maven / Gradle / Ivy

There is a newer version: 2.20.0
Show newest version
/*
 *  Copyright 2015 the original author or authors. 
 *  @https://github.com/scouter-project/scouter
 *
 *  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. 
 * 
 *  The initial idea for this class is from "org.apache.commons.lang.IntHashMap"; 
 *  http://commons.apache.org/commons-lang-2.6-src.zip
 *
 */
package scouter.util;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.NoSuchElementException;

/**
 * 
 * LinkedMap = LinkedList + HashMap
 * 1. 순처 조회및 해쉬조회 가능
 *    - key() Enumeration : 입력된 순서가 보장된 조회 
 *    - get(key) : key에 대한 hash조회
 *    - getFirst() : 첫번째 입력된 데이터 조회
 *    - getLast() : 마지막 입력된 데이터 조회   
 * 2. 입력 순서 유지및 변경 가능
 *    - putFirst- 기존 입력된 데이터를 다시 처음으로 입력
 *    - putLast - 기존 입력된 데이터를 다시 마지막으로 입력
 *    - put - 기존 입력된 데이터를 값만 변경하고 없으면 마지막으로 입력 
 * 3. 최대 Max Size를 지정 및 재설정 가능, 초과시 밀어내기 삭제
 *    - setMax(int)로 최대 크기를 변경가능  
 *    - 밀어내기 삭제시 이벤트 처리  overflowed()
 * 4. intern기능
 *    - 데이터가 존재하면 get()과 같고 없으면  
 *    - create()로 데이터를 만들고
 * 5. 입력 순서를 고려한 데이터 삭제 가능
 *    - remove(key) : 입력된 키를 삭제 
 *    - removeFirst :  처음 입력된 데이터 삭제 
 *    - removeLast : 마지막 입력된 데이터 삭제 
 * 
 * LinkedMap map = new LinkedMap(){
 *   protected Connection create(String key){
 *      return Manager.connect();
 *   }
 *  } 
 *  
 *  Connection con = map.intern("con1");
 *  con != null이 보장된다. intern함수는 값이 nul인경우 create()를 호출하여
 *   새로운 값을 생성하여 저장하고 리턴한다. 
 *   
 *  LinkedMap map = new LinkedMap(){
 *   protected void overflowed(String key, Connection con){
 *      con.close();
 *   }
 *  }.setMax(10);
 *  
 *  Connection con = Manager.connect();
 *  map.put("con10", con);
 *  map.size()==10인 상태에서 put()함수가 호출되면 초과되는 데이터가 
 *  overflowed()에 전달된다.
 * 
* * @author Paul Kim([email protected]) * */ public class LinkedMap { private static final int DEFAULT_CAPACITY = 101; private static final float DEFAULT_LOAD_FACTOR = 0.75f; private LinkedEntry table[]; private LinkedEntry header; private int count; private int threshold; private float loadFactor; public LinkedMap(int initCapacity, float loadFactor) { if (initCapacity < 0) throw new RuntimeException("Capacity Error: " + initCapacity); if (loadFactor <= 0) throw new RuntimeException("Load Count Error: " + loadFactor); if (initCapacity == 0) initCapacity = 1; this.loadFactor = loadFactor; this.table = new LinkedEntry[initCapacity]; this.header = new LinkedEntry(null, null, null); this.header.link_next = header.link_prev = header; threshold = (int) (initCapacity * loadFactor); } public LinkedMap() { this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR); } public int size() { return count; } public synchronized Enumeration keys() { return new Enumer(TYPE.KEYS); } public synchronized Enumeration values() { return new Enumer(TYPE.VALUES); } public synchronized Enumeration> entries() { return new Enumer(TYPE.ENTRIES); } public synchronized boolean containsValue(V value) { if (value == null) { return false; } LinkedEntry tab[] = table; int i = tab.length; while (i-- > 0) { for (LinkedEntry e = tab[i]; e != null; e = e.next) { if (CompareUtil.equals(e.value, value)) { return true; } } } return false; } public synchronized boolean containsKey(Object key) { if (key == null) return false; LinkedEntry tab[] = table; int index = hash(key) % tab.length; for (LinkedEntry e = tab[index]; e != null; e = e.next) { if (CompareUtil.equals(e.key, key)) { return true; } } return false; } public synchronized V get(K key) { if (key == null) return null; LinkedEntry tab[] = table; int index = hash(key) % tab.length; for (LinkedEntry e = tab[index]; e != null; e = e.next) { if (CompareUtil.equals(e.key, key)) { return e.value; } } return null; } public synchronized V getFirstValue() { if (isEmpty()) return null; return this.header.link_next.value; } public synchronized V getLastValue() { if (isEmpty()) return null; return this.header.link_prev.value; } private int hash(Object key) { return (int) (key.hashCode()) & Integer.MAX_VALUE; } protected void rehash() { int oldCapacity = table.length; LinkedEntry oldMap[] = table; int newCapacity = oldCapacity * 2 + 1; LinkedEntry newMap[] = new LinkedEntry[newCapacity]; threshold = (int) (newCapacity * loadFactor); table = newMap; for (int i = oldCapacity; i-- > 0;) { for (LinkedEntry old = oldMap[i]; old != null;) { LinkedEntry e = old; old = old.next; K key = e.key; int index = hash(key) % newCapacity; e.next = newMap[index]; newMap[index] = e; } } } private int max; public LinkedMap setMax(int max) { this.max = max; return this; } private static enum MODE { FORCE_FIRST, FORCE_LAST, FIRST, LAST }; public V put(K key, V value) { return _put(key, value, MODE.LAST); } public V putLast(K key, V value) { return _put(key, value, MODE.FORCE_LAST); } public V putFirst(K key, V value) { return _put(key, value, MODE.FORCE_FIRST); } private synchronized V _put(K key, V value, MODE m) { LinkedEntry tab[] = table; int index = hash(key) % tab.length; for (LinkedEntry e = tab[index]; e != null; e = e.next) { if (CompareUtil.equals(e.key, key)) { V old = e.value; e.value = value; switch (m) { case FORCE_FIRST: if (header.link_next != e) { unchain(e); chain(header, header.link_next, e); } break; case FORCE_LAST: if (header.link_prev != e) { unchain(e); chain(header.link_prev, header, e); } break; } return old; } } if (max > 0) { switch (m) { case FORCE_FIRST: case FIRST: while (count >= max) { K k = header.link_prev.key; V v = remove(k); overflowed(k, v); } break; case FORCE_LAST: case LAST: while (count >= max) { K k = header.link_next.key; V v = remove(k); overflowed(k, v); } break; } } if (count >= threshold) { rehash(); tab = table; index = hash(key) % tab.length; } LinkedEntry e = new LinkedEntry(key, value, tab[index]); tab[index] = e; switch (m) { case FORCE_FIRST: case FIRST: chain(header, header.link_next, e); break; case FORCE_LAST: case LAST: chain(header.link_prev, header, e); break; } count++; return null; } protected void overflowed(K key, V value) { } protected V create(K key) { throw new RuntimeException("not implemented create()"); } public V intern(K key) { return _intern(key, MODE.LAST); } private synchronized V _intern(K key, MODE m) { LinkedEntry tab[] = table; int index = hash(key) % tab.length; for (LinkedEntry e = tab[index]; e != null; e = e.next) { if (CompareUtil.equals(e.key, key)) { V old = e.value; switch (m) { case FORCE_FIRST: if (header.link_next != e) { unchain(e); chain(header, header.link_next, e); } break; case FORCE_LAST: if (header.link_prev != e) { unchain(e); chain(header.link_prev, header, e); } break; } return old; } } V value = create(key); if (value == null) return null; if (max > 0) { switch (m) { case FORCE_FIRST: case FIRST: while (count >= max) { K k = header.link_prev.key; V v = remove(k); overflowed(k, v); } break; case FORCE_LAST: case LAST: while (count >= max) { K k = header.link_next.key; V v = remove(k); overflowed(k, v); } break; } } if (count >= threshold) { rehash(); tab = table; index = hash(key) % tab.length; } LinkedEntry e = new LinkedEntry(key, value, tab[index]); tab[index] = e; switch (m) { case FORCE_FIRST: case FIRST: chain(header, header.link_next, e); break; case FORCE_LAST: case LAST: chain(header.link_prev, header, e); break; } count++; return value; } public synchronized V remove(K key) { if (key == null) return null; LinkedEntry tab[] = table; int index = hash(key) % tab.length; for (LinkedEntry e = tab[index], prev = null; e != null; prev = e, e = e.next) { if (CompareUtil.equals(e.key, key)) { if (prev != null) { prev.next = e.next; } else { tab[index] = e.next; } count--; V oldValue = e.value; e.value = null; // unchain(e); return oldValue; } } return null; } public synchronized V removeFirst() { if (isEmpty()) return null; return remove(header.link_next.key); } public synchronized V removeLast() { if (isEmpty()) return null; return remove(header.link_prev.key); } public boolean isEmpty() { return size() == 0; } public synchronized void clear() { LinkedEntry tab[] = table; for (int index = tab.length; --index >= 0;) tab[index] = null; this.header.link_next = header.link_prev = header; count = 0; } public String toString() { StringBuffer buf = new StringBuffer(); Enumeration> it = entries(); buf.append("{"); for (int i = 0; it.hasMoreElements(); i++) { LinkedEntry e = (LinkedEntry) (it.nextElement()); if (i > 0) buf.append(", "); buf.append(e.getKey() + "=" + e.getValue()); } buf.append("}"); return buf.toString(); } public String toKeyString() { StringBuffer buf = new StringBuffer(); Enumeration it = keys(); buf.append("{"); for (int i = 0; it.hasMoreElements(); i++) { K key = it.nextElement(); if (i > 0) buf.append(", "); buf.append(key); } buf.append("}"); return buf.toString(); } public String toFormatString() { StringBuffer buf = new StringBuffer(); Enumeration it = entries(); buf.append("{\n"); while (it.hasMoreElements()) { LinkedEntry e = (LinkedEntry) it.nextElement(); buf.append("\t").append(e.getKey() + "=" + e.getValue()).append("\n"); } buf.append("}"); return buf.toString(); } private enum TYPE { KEYS, VALUES, ENTRIES } private class Enumer implements Enumeration { TYPE type; LinkedEntry entry = LinkedMap.this.header.link_next; LinkedEntry lastEnt; Enumer(TYPE type) { this.type = type; } public boolean hasMoreElements() { return header != entry && entry != null; } public V nextElement() { if (hasMoreElements()) { LinkedEntry e = lastEnt = entry; entry = e.link_next; switch (type) { case KEYS: return (V) e.key; case VALUES: return (V) e.value; default: return (V) e; } } throw new NoSuchElementException("no more next"); } } private void chain(LinkedEntry link_prev, LinkedEntry link_next, LinkedEntry e) { e.link_prev = link_prev; e.link_next = link_next; link_prev.link_next = e; link_next.link_prev = e; } private void unchain(LinkedEntry e) { e.link_prev.link_next = e.link_next; e.link_next.link_prev = e.link_prev; e.link_prev = null; e.link_next = null; } public static class LinkedEntry { K key; V value; LinkedEntry next; LinkedEntry link_next, link_prev; protected LinkedEntry(K key, V value, LinkedEntry next) { this.key = key; this.value = value; this.next = next; } protected Object clone() { return new LinkedEntry(key, value, (next == null ? null : (LinkedEntry) next.clone())); } public K getKey() { return key; } public V getValue() { return value; } public V setValue(V value) { V oldValue = this.value; this.value = value; return oldValue; } public boolean equals(Object o) { if (!(o instanceof LinkedEntry)) return false; LinkedEntry e = (LinkedEntry) o; return CompareUtil.equals(key, e.key) && CompareUtil.equals(value, e.value); } public int hashCode() { return key.hashCode() ^ (value == null ? 0 : value.hashCode()); } public String toString() { return key + "=" + value; } } public synchronized void sort(Comparator> c) { ArrayList> list = new ArrayList>(this.size()); Enumeration> en = this.entries(); while (en.hasMoreElements()) { LinkedEntry n=en.nextElement(); if(n!=null){ list.add(n); } } Collections.sort(list, c); this.clear(); for (int i = 0; i < list.size(); i++) { LinkedEntry e = list.get(i); this.put(e.getKey(), e.getValue()); } } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy