vanitasvitae/Smack
1
0
Fork 0
mirror of https://github.com/vanitasvitae/Smack.git synced 2024-11-26 14:02:06 +01:00
Code Issues Releases Wiki Activity

Remove old Apache commons collections from codebase

Browse source 
ChatManager's Chat instances are now removed by Chat.close(), removing
the need for a Map with Hard to Weak references.

ChatStateManager can simply use WeakHashMap.
This commit is contained in:
Florian Schmaus 2014-03-17 10:26:39 +01:00
parent f73a3afbca
commit a46d02ca32
17 changed files with 72 additions and 3224 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
core/src/main/java/org/jivesoftware/smack/Chat.java
View file

@ -99,9 +99,8 @@ public class Chat {
* and message type of the message will automatically set to those of this chat. * and message type of the message will automatically set to those of this chat.
* *
* @param message the message to send. * @param message the message to send.
* @throws XMPPException if an error occurs sending the message.
*/ */
public void sendMessage(Message message) throws XMPPException { public void sendMessage(Message message) {
// Force the recipient, message type, and thread ID since the user elected // Force the recipient, message type, and thread ID since the user elected
// to send the message through this chat object. // to send the message through this chat object.
message.setTo(participant); message.setTo(participant);

11
core/src/main/java/org/jivesoftware/smack/ChatManager.java
View file

@ -19,6 +19,7 @@ package org.jivesoftware.smack;
import java.util.Collection; import java.util.Collection;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
@ -33,7 +34,6 @@ import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Message.Type; import org.jivesoftware.smack.packet.Message.Type;
import org.jivesoftware.smack.packet.Packet; import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.util.StringUtils; import org.jivesoftware.smack.util.StringUtils;
import org.jivesoftware.smack.util.collections.ReferenceMap;
/** /**
* The chat manager keeps track of references to all current chats. It will not hold any references * The chat manager keeps track of references to all current chats. It will not hold any references
@ -87,20 +87,17 @@ public class ChatManager {
/** /**
* Maps thread ID to chat. * Maps thread ID to chat.
*/ */
private Map<String, Chat> threadChats = Collections.synchronizedMap(new ReferenceMap<String, Chat>(ReferenceMap.HARD, private Map<String, Chat> threadChats = Collections.synchronizedMap(new HashMap<String, Chat>());
ReferenceMap.WEAK));
/** /**
* Maps jids to chats * Maps jids to chats
*/ */
private Map<String, Chat> jidChats = Collections.synchronizedMap(new ReferenceMap<String, Chat>(ReferenceMap.HARD, private Map<String, Chat> jidChats = Collections.synchronizedMap(new HashMap<String, Chat>());
ReferenceMap.WEAK));
/** /**
* Maps base jids to chats * Maps base jids to chats
*/ */
private Map<String, Chat> baseJidChats = Collections.synchronizedMap(new ReferenceMap<String, Chat>(ReferenceMap.HARD, private Map<String, Chat> baseJidChats = Collections.synchronizedMap(new HashMap<String, Chat>());
ReferenceMap.WEAK));
private Set<ChatManagerListener> chatManagerListeners private Set<ChatManagerListener> chatManagerListeners
= new CopyOnWriteArraySet<ChatManagerListener>(); = new CopyOnWriteArraySet<ChatManagerListener>();

65
core/src/main/java/org/jivesoftware/smack/util/Cache.java
View file

@ -16,8 +16,6 @@
*/ */
package org.jivesoftware.smack.util; package org.jivesoftware.smack.util;
import org.jivesoftware.smack.util.collections.AbstractMapEntry;
import java.util.*; import java.util.*;
import java.util.logging.Logger; import java.util.logging.Logger;
@ -675,4 +673,67 @@ public class Cache<K, V> implements Map<K, V> {
return object.toString(); return object.toString();
} }
} }
static class AbstractMapEntry<K, V> implements Map.Entry<K, V> {
final K key;
V value;
AbstractMapEntry(K key, V value) {
this.key = key;
this.value = value;
}
@Override
public K getKey() {
return key;
}
@Override
public V getValue() {
return value;
}
@Override
public V setValue(V value) {
V answer = this.value;
this.value = value;
return answer;
}
/**
* Compares this Map Entry with another Map Entry.
* <p/>
* Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
*
* @param obj the object to compare to
* @return true if equal key and value
*/
@SuppressWarnings("rawtypes")
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof Map.Entry == false) {
return false;
}
Map.Entry other = (Map.Entry) obj;
return (getKey() == null ? other.getKey() == null : getKey().equals(other.getKey()))
&& (getValue() == null ? other.getValue() == null : getValue().equals(
other.getValue()));
}
/**
* Gets a hashCode compatible with the equals method.
* <p/>
* Implemented per API documentation of {@link java.util.Map.Entry#hashCode()}
*
* @return a suitable hash code
*/
@Override
public int hashCode() {
return (getKey() == null ? 0 : getKey().hashCode())
^ (getValue() == null ? 0 : getValue().hashCode());
}
}
} }

89
core/src/main/java/org/jivesoftware/smack/util/collections/AbstractEmptyIterator.java
View file

@ -1,89 +0,0 @@
/**
*
* Copyright 2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.NoSuchElementException;
/**
* Provides an implementation of an empty iterator.
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:24 $
* @since Commons Collections 3.1
*/
abstract class AbstractEmptyIterator <E> {
/**
* Constructor.
*/
protected AbstractEmptyIterator() {
super();
}
public boolean hasNext() {
return false;
}
public E next() {
throw new NoSuchElementException("Iterator contains no elements");
}
public boolean hasPrevious() {
return false;
}
public E previous() {
throw new NoSuchElementException("Iterator contains no elements");
}
public int nextIndex() {
return 0;
}
public int previousIndex() {
return -1;
}
public void add(E obj) {
throw new UnsupportedOperationException("add() not supported for empty Iterator");
}
public void set(E obj) {
throw new IllegalStateException("Iterator contains no elements");
}
public void remove() {
throw new IllegalStateException("Iterator contains no elements");
}
public E getKey() {
throw new IllegalStateException("Iterator contains no elements");
}
public E getValue() {
throw new IllegalStateException("Iterator contains no elements");
}
public E setValue(E value) {
throw new IllegalStateException("Iterator contains no elements");
}
public void reset() {
// do nothing
}
}

1339
core/src/main/java/org/jivesoftware/smack/util/collections/AbstractHashedMap.java
View file

File diff suppressed because it is too large Load diff

80
core/src/main/java/org/jivesoftware/smack/util/collections/AbstractKeyValue.java
View file

@ -1,80 +0,0 @@
/**
*
* Copyright 2003-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
/**
* Abstract pair class to assist with creating KeyValue and MapEntry implementations.
*
* @author James Strachan
* @author Michael A. Smith
* @author Neil O'Toole
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:32 $
* @since Commons Collections 3.0
*/
public abstract class AbstractKeyValue <K,V> implements KeyValue<K, V> {
/**
* The key
*/
protected K key;
/**
* The value
*/
protected V value;
/**
* Constructs a new pair with the specified key and given value.
*
* @param key the key for the entry, may be null
* @param value the value for the entry, may be null
*/
protected AbstractKeyValue(K key, V value) {
super();
this.key = key;
this.value = value;
}
/**
* Gets the key from the pair.
*
* @return the key
*/
public K getKey() {
return key;
}
/**
* Gets the value from the pair.
*
* @return the value
*/
public V getValue() {
return value;
}
/**
* Gets a debugging String view of the pair.
*
* @return a String view of the entry
*/
public String toString() {
return new StringBuilder().append(getKey()).append('=').append(getValue()).toString();
}
}

89
core/src/main/java/org/jivesoftware/smack/util/collections/AbstractMapEntry.java
View file

@ -1,89 +0,0 @@
/**
*
* Copyright 2003-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.Map;
/**
* Abstract Pair class to assist with creating correct Map Entry implementations.
*
* @author James Strachan
* @author Michael A. Smith
* @author Neil O'Toole
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:32 $
* @since Commons Collections 3.0
*/
public abstract class AbstractMapEntry <K,V> extends AbstractKeyValue<K, V> implements Map.Entry<K, V> {
/**
* Constructs a new entry with the given key and given value.
*
* @param key the key for the entry, may be null
* @param value the value for the entry, may be null
*/
protected AbstractMapEntry(K key, V value) {
super(key, value);
}
// Map.Entry interface
//-------------------------------------------------------------------------
/**
* Sets the value stored in this Map Entry.
* <p/>
* This Map Entry is not connected to a Map, so only the local data is changed.
*
* @param value the new value
* @return the previous value
*/
public V setValue(V value) {
V answer = this.value;
this.value = value;
return answer;
}
/**
* Compares this Map Entry with another Map Entry.
* <p/>
* Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
*
* @param obj the object to compare to
* @return true if equal key and value
*/
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof Map.Entry == false) {
return false;
}
Map.Entry other = (Map.Entry) obj;
return (getKey() == null ? other.getKey() == null : getKey().equals(other.getKey())) && (getValue() == null ? other.getValue() == null : getValue().equals(other.getValue()));
}
/**
* Gets a hashCode compatible with the equals method.
* <p/>
* Implemented per API documentation of {@link java.util.Map.Entry#hashCode()}
*
* @return a suitable hash code
*/
public int hashCode() {
return (getKey() == null ? 0 : getKey().hashCode()) ^ (getValue() == null ? 0 : getValue().hashCode());
}
}

1026
core/src/main/java/org/jivesoftware/smack/util/collections/AbstractReferenceMap.java
View file

File diff suppressed because it is too large Load diff

65
core/src/main/java/org/jivesoftware/smack/util/collections/DefaultMapEntry.java
View file

@ -1,65 +0,0 @@
/**
*
* Copyright 2001-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.Map;
/**
* A restricted implementation of {@link java.util.Map.Entry} that prevents
* the MapEntry contract from being broken.
*
* @author James Strachan
* @author Michael A. Smith
* @author Neil O'Toole
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:32 $
* @since Commons Collections 3.0
*/
public final class DefaultMapEntry <K,V> extends AbstractMapEntry<K, V> {
/**
* Constructs a new entry with the specified key and given value.
*
* @param key the key for the entry, may be null
* @param value the value for the entry, may be null
*/
public DefaultMapEntry(final K key, final V value) {
super(key, value);
}
/**
* Constructs a new entry from the specified KeyValue.
*
* @param pair the pair to copy, must not be null
* @throws NullPointerException if the entry is null
*/
public DefaultMapEntry(final KeyValue<K, V> pair) {
super(pair.getKey(), pair.getValue());
}
/**
* Constructs a new entry from the specified MapEntry.
*
* @param entry the entry to copy, must not be null
* @throws NullPointerException if the entry is null
*/
public DefaultMapEntry(final Map.Entry<K, V> entry) {
super(entry.getKey(), entry.getValue());
}
}

58
core/src/main/java/org/jivesoftware/smack/util/collections/EmptyIterator.java
View file

@ -1,58 +0,0 @@
/**
*
* Copyright 2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.Iterator;
/**
* Provides an implementation of an empty iterator.
* <p/>
* This class provides an implementation of an empty iterator.
* This class provides for binary compatability between Commons Collections
* 2.1.1 and 3.1 due to issues with <code>IteratorUtils</code>.
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:24 $
* @since Commons Collections 2.1.1 and 3.1
*/
public class EmptyIterator <E> extends AbstractEmptyIterator<E> implements ResettableIterator<E> {
/**
* Singleton instance of the iterator.
*
* @since Commons Collections 3.1
*/
public static final ResettableIterator RESETTABLE_INSTANCE = new EmptyIterator();
/**
* Singleton instance of the iterator.
*
* @since Commons Collections 2.1.1 and 3.1
*/
public static final Iterator INSTANCE = RESETTABLE_INSTANCE;
public static <T> Iterator<T> getInstance() {
return INSTANCE;
}
/**
* Constructor.
*/
protected EmptyIterator() {
super();
}
}

42
core/src/main/java/org/jivesoftware/smack/util/collections/EmptyMapIterator.java
View file

@ -1,42 +0,0 @@
/**
*
* Copyright 2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
/**
* Provides an implementation of an empty map iterator.
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:24 $
* @since Commons Collections 3.1
*/
public class EmptyMapIterator extends AbstractEmptyIterator implements MapIterator, ResettableIterator {
/**
* Singleton instance of the iterator.
*
* @since Commons Collections 3.1
*/
public static final MapIterator INSTANCE = new EmptyMapIterator();
/**
* Constructor.
*/
protected EmptyMapIterator() {
super();
}
}

61
core/src/main/java/org/jivesoftware/smack/util/collections/IterableMap.java
View file

@ -1,61 +0,0 @@
/**
*
* Copyright 2003-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.Map;
/**
* Defines a map that can be iterated directly without needing to create an entry set.
* <p/>
* A map iterator is an efficient way of iterating over maps.
* There is no need to access the entry set or cast to Map Entry objects.
* <pre>
* IterableMap map = new HashedMap();
* MapIterator it = map.mapIterator();
* while (it.hasNext()) {
* Object key = it.next();
* Object value = it.getValue();
* it.setValue("newValue");
* }
* </pre>
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:19 $
* @since Commons Collections 3.0
*/
public interface IterableMap <K,V> extends Map<K, V> {
/**
* Obtains a <code>MapIterator</code> over the map.
* <p/>
* A map iterator is an efficient way of iterating over maps.
* There is no need to access the entry set or cast to Map Entry objects.
* <pre>
* IterableMap map = new HashedMap();
* MapIterator it = map.mapIterator();
* while (it.hasNext()) {
* Object key = it.next();
* Object value = it.getValue();
* it.setValue("newValue");
* }
* </pre>
*
* @return a map iterator
*/
MapIterator<K, V> mapIterator();
}

46
core/src/main/java/org/jivesoftware/smack/util/collections/KeyValue.java
View file

@ -1,46 +0,0 @@
/**
*
* Copyright 2003-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
/**
* Defines a simple key value pair.
* <p/>
* A Map Entry has considerable additional semantics over and above a simple
* key-value pair. This interface defines the minimum key value, with just the
* two get methods.
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:19 $
* @since Commons Collections 3.0
*/
public interface KeyValue <K,V> {
/**
* Gets the key from the pair.
*
* @return the key
*/
K getKey();
/**
* Gets the value from the pair.
*
* @return the value
*/
V getValue();
}

109
core/src/main/java/org/jivesoftware/smack/util/collections/MapIterator.java
View file

@ -1,109 +0,0 @@
/**
*
* Copyright 2003-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.Iterator;
/**
* Defines an iterator that operates over a <code>Map</code>.
* <p/>
* This iterator is a special version designed for maps. It can be more
* efficient to use this rather than an entry set iterator where the option
* is available, and it is certainly more convenient.
* <p/>
* A map that provides this interface may not hold the data internally using
* Map Entry objects, thus this interface can avoid lots of object creation.
* <p/>
* In use, this iterator iterates through the keys in the map. After each call
* to <code>next()</code>, the <code>getValue()</code> method provides direct
* access to the value. The value can also be set using <code>setValue()</code>.
* <pre>
* MapIterator it = map.mapIterator();
* while (it.hasNext()) {
* Object key = it.next();
* Object value = it.getValue();
* it.setValue(newValue);
* }
* </pre>
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:19 $
* @since Commons Collections 3.0
*/
public interface MapIterator <K,V> extends Iterator<K> {
/**
* Checks to see if there are more entries still to be iterated.
*
* @return <code>true</code> if the iterator has more elements
*/
boolean hasNext();
/**
* Gets the next <em>key</em> from the <code>Map</code>.
*
* @return the next key in the iteration
* @throws java.util.NoSuchElementException
* if the iteration is finished
*/
K next();
//-----------------------------------------------------------------------
/**
* Gets the current key, which is the key returned by the last call
* to <code>next()</code>.
*
* @return the current key
* @throws IllegalStateException if <code>next()</code> has not yet been called
*/
K getKey();
/**
* Gets the current value, which is the value associated with the last key
* returned by <code>next()</code>.
*
* @return the current value
* @throws IllegalStateException if <code>next()</code> has not yet been called
*/
V getValue();
//-----------------------------------------------------------------------
/**
* Removes the last returned key from the underlying <code>Map</code> (optional operation).
* <p/>
* This method can be called once per call to <code>next()</code>.
*
* @throws UnsupportedOperationException if remove is not supported by the map
* @throws IllegalStateException if <code>next()</code> has not yet been called
* @throws IllegalStateException if <code>remove()</code> has already been called
* since the last call to <code>next()</code>
*/
void remove();
/**
* Sets the value associated with the current key (optional operation).
*
* @param value the new value
* @return the previous value
* @throws UnsupportedOperationException if setValue is not supported by the map
* @throws IllegalStateException if <code>next()</code> has not yet been called
* @throws IllegalStateException if <code>remove()</code> has been called since the
* last call to <code>next()</code>
*/
V setValue(V value);
}

161
core/src/main/java/org/jivesoftware/smack/util/collections/ReferenceMap.java
View file

@ -1,161 +0,0 @@
/**
*
* Copyright 2002-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
* A <code>Map</code> implementation that allows mappings to be
* removed by the garbage collector.
* <p/>
* When you construct a <code>ReferenceMap</code>, you can specify what kind
* of references are used to store the map's keys and values.
* If non-hard references are used, then the garbage collector can remove
* mappings if a key or value becomes unreachable, or if the JVM's memory is
* running low. For information on how the different reference types behave,
* see {@link java.lang.ref.Reference}.
* <p/>
* Different types of references can be specified for keys and values.
* The keys can be configured to be weak but the values hard,
* in which case this class will behave like a
* <a href="http://java.sun.com/j2se/1.4/docs/api/java/util/WeakHashMap.html">
* <code>WeakHashMap</code></a>. However, you can also specify hard keys and
* weak values, or any other combination. The default constructor uses
* hard keys and soft values, providing a memory-sensitive cache.
* <p/>
* This map is similar to ReferenceIdentityMap.
* It differs in that keys and values in this class are compared using <code>equals()</code>.
* <p/>
* This {@link java.util.Map} implementation does <i>not</i> allow null elements.
* Attempting to add a null key or value to the map will raise a <code>NullPointerException</code>.
* <p/>
* This implementation is not synchronized.
* You can use {@link java.util.Collections#synchronizedMap} to
* provide synchronized access to a <code>ReferenceMap</code>.
* Remember that synchronization will not stop the garbage collecter removing entries.
* <p/>
* All the available iterators can be reset back to the start by casting to
* <code>ResettableIterator</code> and calling <code>reset()</code>.
* <p/>
* NOTE: As from Commons Collections 3.1 this map extends <code>AbstractReferenceMap</code>
* (previously it extended AbstractMap). As a result, the implementation is now
* extensible and provides a <code>MapIterator</code>.
*
* @author Paul Jack
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:32 $
* @see java.lang.ref.Reference
* @since Commons Collections 3.0 (previously in main package v2.1)
*/
public class ReferenceMap <K,V> extends AbstractReferenceMap<K, V> implements Serializable {
/**
* Serialization version
*/
private static final long serialVersionUID = 1555089888138299607L;
/**
* Constructs a new <code>ReferenceMap</code> that will
* use hard references to keys and soft references to values.
*/
public ReferenceMap() {
super(HARD, SOFT, DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, false);
}
/**
* Constructs a new <code>ReferenceMap</code> that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param valueType the type of reference to use for values;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
*/
public ReferenceMap(int keyType, int valueType) {
super(keyType, valueType, DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, false);
}
/**
* Constructs a new <code>ReferenceMap</code> that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param valueType the type of reference to use for values;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param purgeValues should the value be automatically purged when the
* key is garbage collected
*/
public ReferenceMap(int keyType, int valueType, boolean purgeValues) {
super(keyType, valueType, DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, purgeValues);
}
/**
* Constructs a new <code>ReferenceMap</code> with the
* specified reference types, load factor and initial
* capacity.
*
* @param keyType the type of reference to use for keys;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param valueType the type of reference to use for values;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param capacity the initial capacity for the map
* @param loadFactor the load factor for the map
*/
public ReferenceMap(int keyType, int valueType, int capacity, float loadFactor) {
super(keyType, valueType, capacity, loadFactor, false);
}
/**
* Constructs a new <code>ReferenceMap</code> with the
* specified reference types, load factor and initial
* capacity.
*
* @param keyType the type of reference to use for keys;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param valueType the type of reference to use for values;
* must be {@link #HARD}, {@link #SOFT}, {@link #WEAK}
* @param capacity the initial capacity for the map
* @param loadFactor the load factor for the map
* @param purgeValues should the value be automatically purged when the
* key is garbage collected
*/
public ReferenceMap(int keyType, int valueType, int capacity, float loadFactor, boolean purgeValues) {
super(keyType, valueType, capacity, loadFactor, purgeValues);
}
//-----------------------------------------------------------------------
/**
* Write the map out using a custom routine.
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
doWriteObject(out);
}
/**
* Read the map in using a custom routine.
*/
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
doReadObject(in);
}
}

38
core/src/main/java/org/jivesoftware/smack/util/collections/ResettableIterator.java
View file

@ -1,38 +0,0 @@
/**
*
* Copyright 2003-2004 The Apache Software Foundation
*
* 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.jivesoftware.smack.util.collections;
import java.util.Iterator;
/**
* Defines an iterator that can be reset back to an initial state.
* <p/>
* This interface allows an iterator to be repeatedly reused.
*
* @author Matt Hall, John Watkinson, Stephen Colebourne
* @version $Revision: 1.1 $ $Date: 2005/10/11 17:05:19 $
* @since Commons Collections 3.0
*/
public interface ResettableIterator <E> extends Iterator<E> {
/**
* Resets the iterator back to the position at which the iterator
* was created.
*/
public void reset();
}

14
extensions/src/main/java/org/jivesoftware/smackx/chatstates/ChatStateManager.java
View file

@ -26,20 +26,18 @@ import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.Manager; import org.jivesoftware.smack.Manager;
import org.jivesoftware.smack.MessageListener; import org.jivesoftware.smack.MessageListener;
import org.jivesoftware.smack.PacketInterceptor; import org.jivesoftware.smack.PacketInterceptor;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.filter.NotFilter; import org.jivesoftware.smack.filter.NotFilter;
import org.jivesoftware.smack.filter.PacketExtensionFilter; import org.jivesoftware.smack.filter.PacketExtensionFilter;
import org.jivesoftware.smack.filter.PacketFilter; import org.jivesoftware.smack.filter.PacketFilter;
import org.jivesoftware.smack.packet.Message; import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Packet; import org.jivesoftware.smack.packet.Packet;
import org.jivesoftware.smack.packet.PacketExtension; import org.jivesoftware.smack.packet.PacketExtension;
import org.jivesoftware.smack.util.collections.ReferenceMap;
import org.jivesoftware.smackx.chatstates.packet.ChatStateExtension; import org.jivesoftware.smackx.chatstates.packet.ChatStateExtension;
import org.jivesoftware.smackx.disco.ServiceDiscoveryManager; import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
/** /**
* Handles chat state for all chats on a particular XMPPConnection. This class manages both the * Handles chat state for all chats on a particular XMPPConnection. This class manages both the
* packet extensions and the disco response neccesary for compliance with * packet extensions and the disco response necessary for compliance with
* <a href="http://www.xmpp.org/extensions/xep-0085.html">XEP-0085</a>. * <a href="http://www.xmpp.org/extensions/xep-0085.html">XEP-0085</a>.
* *
* NOTE: {@link org.jivesoftware.smackx.chatstates.ChatStateManager#getInstance(org.jivesoftware.smack.XMPPConnection)} * NOTE: {@link org.jivesoftware.smackx.chatstates.ChatStateManager#getInstance(org.jivesoftware.smack.XMPPConnection)}
@ -80,8 +78,7 @@ public class ChatStateManager extends Manager {
/** /**
* Maps chat to last chat state. * Maps chat to last chat state.
*/ */
private final Map<Chat, ChatState> chatStates = private final Map<Chat, ChatState> chatStates = new WeakHashMap<Chat, ChatState>();
new ReferenceMap<Chat, ChatState>(ReferenceMap.WEAK, ReferenceMap.HARD);
private ChatStateManager(XMPPConnection connection) { private ChatStateManager(XMPPConnection connection) {
super(connection); super(connection);
@ -100,11 +97,8 @@ public class ChatStateManager extends Manager {
* *
* @param newState the new state of the chat * @param newState the new state of the chat
* @param chat the chat. * @param chat the chat.
* @throws org.jivesoftware.smack.XMPPException
* when there is an error sending the message
* packet.
*/ */
public void setCurrentState(ChatState newState, Chat chat) throws XMPPException { public void setCurrentState(ChatState newState, Chat chat) {
if(chat == null || newState == null) { if(chat == null || newState == null) {
throw new IllegalArgumentException("Arguments cannot be null."); throw new IllegalArgumentException("Arguments cannot be null.");
} }
@ -133,7 +127,7 @@ public class ChatStateManager extends Manager {
return connection().hashCode(); return connection().hashCode();
} }
private boolean updateChatState(Chat chat, ChatState newState) { private synchronized boolean updateChatState(Chat chat, ChatState newState) {
ChatState lastChatState = chatStates.get(chat); ChatState lastChatState = chatStates.get(chat);
if (lastChatState != newState) { if (lastChatState != newState) {
chatStates.put(chat, newState); chatStates.put(chat, newState);