// Copyright 2003-2005 Arthur van Hoff Rick Blair
// Licensed under Apache License version 2.0
// Original license LGPL
package javax.jmdns.impl;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.jmdns.impl.constants.DNSRecordClass;
import javax.jmdns.impl.constants.DNSRecordType;
/**
* A table of DNS entries. This is a map table which can handle multiple entries with the same name.
* <p/>
* Storing multiple entries with the same name is implemented using a linked list. This is hidden from the user and can change in later implementation.
* <p/>
* Here's how to iterate over all entries:
*
* <pre>
* for (Iterator i=dnscache.allValues().iterator(); i.hasNext(); ) {
* DNSEntry entry = i.next();
* ...do something with entry...
* }
* </pre>
* <p/>
* And here's how to iterate over all entries having a given name:
*
* <pre>
* for (Iterator i=dnscache.getDNSEntryList(name).iterator(); i.hasNext(); ) {
* DNSEntry entry = i.next();
* ...do something with entry...
* }
* </pre>
*
* @author Arthur van Hoff, Werner Randelshofer, Rick Blair, Pierre Frisch
*/
public class DNSCache extends AbstractMap<String, List<? extends DNSEntry>> {
// private static Logger logger = Logger.getLogger(DNSCache.class.getName());
private transient Set<Map.Entry<String, List<? extends DNSEntry>>> _entrySet = null;
/**
*
*/
public static final DNSCache EmptyCache = new _EmptyCache();
static final class _EmptyCache extends DNSCache {
/**
* {@inheritDoc}
*/
@Override
public int size() {
return 0;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isEmpty() {
return true;
}
/**
* {@inheritDoc}
*/
@Override
public boolean containsKey(Object key) {
return false;
}
/**
* {@inheritDoc}
*/
@Override
public boolean containsValue(Object value) {
return false;
}
/**
* {@inheritDoc}
*/
@Override
public List<DNSEntry> get(Object key) {
return null;
}
/**
* {@inheritDoc}
*/
@Override
public Set<String> keySet() {
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override
public Collection<List<? extends DNSEntry>> values() {
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override
public Set<Map.Entry<String, List<? extends DNSEntry>>> entrySet() {
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override
public boolean equals(Object o) {
return (o instanceof Map) && ((Map<?, ?>) o).size() == 0;
}
/**
* {@inheritDoc}
*/
@Override
public List<? extends DNSEntry> put(String key, List<? extends DNSEntry> value) {
return null;
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return 0;
}
}
/**
*
*/
protected static class _CacheEntry extends Object implements Map.Entry<String, List<? extends DNSEntry>> {
private List<? extends DNSEntry> _value;
private String _key;
/**
* @param key
* @param value
*/
protected _CacheEntry(String key, List<? extends DNSEntry> value) {
super();
_key = (key != null ? key.trim().toLowerCase() : null);
_value = value;
}
/**
* @param entry
*/
protected _CacheEntry(Map.Entry<String, List<? extends DNSEntry>> entry) {
super();
if (entry instanceof _CacheEntry) {
_key = ((_CacheEntry) entry).getKey();
_value = ((_CacheEntry) entry).getValue();
}
}
/**
* {@inheritDoc}
*/
@Override
public String getKey() {
return (_key != null ? _key : "");
}
/**
* {@inheritDoc}
*/
@Override
public List<? extends DNSEntry> getValue() {
return _value;
}
/**
* {@inheritDoc}
*/
@Override
public List<? extends DNSEntry> setValue(List<? extends DNSEntry> value) {
List<? extends DNSEntry> oldValue = _value;
_value = value;
return oldValue;
}
/**
* Returns <tt>true</tt> if this list contains no elements.
*
* @return <tt>true</tt> if this list contains no elements
*/
public boolean isEmpty() {
return this.getValue().isEmpty();
}
/**
* {@inheritDoc}
*/
@Override
public boolean equals(Object entry) {
if (!(entry instanceof Map.Entry)) {
return false;
}
return this.getKey().equals(((Map.Entry<?, ?>) entry).getKey()) && this.getValue().equals(((Map.Entry<?, ?>) entry).getValue());
}
/**
* {@inheritDoc}
*/
@Override
public int hashCode() {
return (_key == null ? 0 : _key.hashCode());
}
/**
* {@inheritDoc}
*/
@Override
public synchronized String toString() {
StringBuffer aLog = new StringBuffer(200);
aLog.append("\n\t\tname '");
aLog.append(_key);
aLog.append("' ");
if ((_value != null) && (!_value.isEmpty())) {
for (DNSEntry entry : _value) {
aLog.append("\n\t\t\t");
aLog.append(entry.toString());
}
} else {
aLog.append(" no entries");
}
return aLog.toString();
}
}
/**
*
*/
public DNSCache() {
this(1024);
}
/**
* @param map
*/
public DNSCache(DNSCache map) {
this(map != null ? map.size() : 1024);
if (map != null) {
this.putAll(map);
}
}
/**
* Create a table with a given initial size.
*
* @param initialCapacity
*/
public DNSCache(int initialCapacity) {
super();
_entrySet = new HashSet<Map.Entry<String, List<? extends DNSEntry>>>(initialCapacity);
}
// ====================================================================
// Map
/*
* (non-Javadoc)
* @see java.util.AbstractMap#entrySet()
*/
@Override
public Set<Map.Entry<String, List<? extends DNSEntry>>> entrySet() {
if (_entrySet == null) {
_entrySet = new HashSet<Map.Entry<String, List<? extends DNSEntry>>>();
}
return _entrySet;
}
/**
* @param key
* @return map entry for the key
*/
protected Map.Entry<String, List<? extends DNSEntry>> getEntry(String key) {
String stringKey = (key != null ? key.trim().toLowerCase() : null);
for (Map.Entry<String, List<? extends DNSEntry>> entry : this.entrySet()) {
if (stringKey != null) {
if (stringKey.equals(entry.getKey())) {
return entry;
}
} else {
if (entry.getKey() == null) {
return entry;
}
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public List<? extends DNSEntry> put(String key, List<? extends DNSEntry> value) {
synchronized (this) {
List<? extends DNSEntry> oldValue = null;
Map.Entry<String, List<? extends DNSEntry>> oldEntry = this.getEntry(key);
if (oldEntry != null) {
oldValue = oldEntry.setValue(value);
} else {
this.entrySet().add(new _CacheEntry(key, value));
}
return oldValue;
}
}
/**
* {@inheritDoc}
*/
@Override
protected Object clone() throws CloneNotSupportedException {
return new DNSCache(this);
}
// ====================================================================
/**
* Returns all entries in the cache
*
* @return all entries in the cache
*/
public synchronized Collection<DNSEntry> allValues() {
List<DNSEntry> allValues = new ArrayList<DNSEntry>();
for (List<? extends DNSEntry> entry : this.values()) {
if (entry != null) {
allValues.addAll(entry);
}
}
return allValues;
}
/**
* Iterate only over items with matching name. Returns an list of DNSEntry or null. To retrieve all entries, one must iterate over this linked list.
*
* @param name
* @return list of DNSEntries
*/
public synchronized Collection<? extends DNSEntry> getDNSEntryList(String name) {
Collection<? extends DNSEntry> entryList = this._getDNSEntryList(name);
if (entryList != null) {
entryList = new ArrayList<DNSEntry>(entryList);
} else {
entryList = Collections.emptyList();
}
return entryList;
}
private Collection<? extends DNSEntry> _getDNSEntryList(String name) {
return this.get(name != null ? name.toLowerCase() : null);
}
/**
* Get a matching DNS entry from the table (using isSameEntry). Returns the entry that was found.
*
* @param dnsEntry
* @return DNSEntry
*/
public synchronized DNSEntry getDNSEntry(DNSEntry dnsEntry) {
DNSEntry result = null;
if (dnsEntry != null) {
Collection<? extends DNSEntry> entryList = this._getDNSEntryList(dnsEntry.getKey());
if (entryList != null) {
for (DNSEntry testDNSEntry : entryList) {
if (testDNSEntry.isSameEntry(dnsEntry)) {
result = testDNSEntry;
break;
}
}
}
}
return result;
}
/**
* Get a matching DNS entry from the table.
*
* @param name
* @param type
* @param recordClass
* @return DNSEntry
*/
public synchronized DNSEntry getDNSEntry(String name, DNSRecordType type, DNSRecordClass recordClass) {
DNSEntry result = null;
Collection<? extends DNSEntry> entryList = this._getDNSEntryList(name);
if (entryList != null) {
for (DNSEntry testDNSEntry : entryList) {
if (testDNSEntry.getRecordType().equals(type) && ((DNSRecordClass.CLASS_ANY == recordClass) || testDNSEntry.getRecordClass().equals(recordClass))) {
result = testDNSEntry;
break;
}
}
}
return result;
}
/**
* Get all matching DNS entries from the table.
*
* @param name
* @param type
* @param recordClass
* @return list of entries
*/
public synchronized Collection<? extends DNSEntry> getDNSEntryList(String name, DNSRecordType type, DNSRecordClass recordClass) {
Collection<? extends DNSEntry> entryList = this._getDNSEntryList(name);
if (entryList != null) {
entryList = new ArrayList<DNSEntry>(entryList);
for (Iterator<? extends DNSEntry> i = entryList.iterator(); i.hasNext();) {
DNSEntry testDNSEntry = i.next();
if (!testDNSEntry.getRecordType().equals(type) || ((DNSRecordClass.CLASS_ANY != recordClass) && !testDNSEntry.getRecordClass().equals(recordClass))) {
i.remove();
}
}
} else {
entryList = Collections.emptyList();
}
return entryList;
}
/**
* Adds an entry to the table.
*
* @param dnsEntry
* @return true if the entry was added
*/
public synchronized boolean addDNSEntry(final DNSEntry dnsEntry) {
boolean result = false;
if (dnsEntry != null) {
Map.Entry<String, List<? extends DNSEntry>> oldEntry = this.getEntry(dnsEntry.getKey());
List<DNSEntry> aNewValue = null;
if (oldEntry != null) {
aNewValue = new ArrayList<DNSEntry>(oldEntry.getValue());
} else {
aNewValue = new ArrayList<DNSEntry>();
}
aNewValue.add(dnsEntry);
if (oldEntry != null) {
oldEntry.setValue(aNewValue);
} else {
this.entrySet().add(new _CacheEntry(dnsEntry.getKey(), aNewValue));
}
// This is probably not very informative
result = true;
}
return result;
}
/**
* Removes a specific entry from the table. Returns true if the entry was found.
*
* @param dnsEntry
* @return true if the entry was removed
*/
public synchronized boolean removeDNSEntry(DNSEntry dnsEntry) {
boolean result = false;
if (dnsEntry != null) {
Map.Entry<String, List<? extends DNSEntry>> existingEntry = this.getEntry(dnsEntry.getKey());
if (existingEntry != null) {
result = existingEntry.getValue().remove(dnsEntry);
// If we just removed the last one we need to get rid of the entry
if (existingEntry.getValue().isEmpty()) {
this.entrySet().remove(existingEntry);
}
}
}
return result;
}
/**
* Replace an existing entry by a new one.<br/>
* <b>Note:</b> the 2 entries must have the same key.
*
* @param newDNSEntry
* @param existingDNSEntry
* @return <code>true</code> if the entry has been replace, <code>false</code> otherwise.
*/
public synchronized boolean replaceDNSEntry(DNSEntry newDNSEntry, DNSEntry existingDNSEntry) {
boolean result = false;
if ((newDNSEntry != null) && (existingDNSEntry != null) && (newDNSEntry.getKey().equals(existingDNSEntry.getKey()))) {
Map.Entry<String, List<? extends DNSEntry>> oldEntry = this.getEntry(newDNSEntry.getKey());
List<DNSEntry> aNewValue = null;
if (oldEntry != null) {
aNewValue = new ArrayList<DNSEntry>(oldEntry.getValue());
} else {
aNewValue = new ArrayList<DNSEntry>();
}
aNewValue.remove(existingDNSEntry);
aNewValue.add(newDNSEntry);
if (oldEntry != null) {
oldEntry.setValue(aNewValue);
} else {
this.entrySet().add(new _CacheEntry(newDNSEntry.getKey(), aNewValue));
}
// This is probably not very informative
result = true;
}
return result;
}
/**
* {@inheritDoc}
*/
@Override
public synchronized String toString() {
StringBuffer aLog = new StringBuffer(2000);
aLog.append("\t---- cache ----");
for (Map.Entry<String, List<? extends DNSEntry>> entry : this.entrySet()) {
aLog.append("\n\t\t");
aLog.append(entry.toString());
}
return aLog.toString();
}
}