You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@river.apache.org by pe...@apache.org on 2011/10/09 04:14:01 UTC
svn commit: r1180519 [1/2] - in /river/jtsk/skunk/peterConcurrentPolicy:
src/net/jini/loader/pref/ src/net/jini/security/policy/
src/org/apache/river/api/delegates/ src/org/apache/river/api/security/
src/org/apache/river/impl/security/dos/ src/org/apac...
Author: peter_firmstone
Date: Sun Oct 9 02:13:59 2011
New Revision: 1180519
URL: http://svn.apache.org/viewvc?rev=1180519&view=rev
Log:
Adding support for Serialization in ReferenceCollections
Added:
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/AbstractSerializationOfRC.java (with props)
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/NullIterator.java (with props)
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceSerializationFactory.java (with props)
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceSerializedForm.java (with props)
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/Referrer.java (with props)
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/SerialDataReferenceCollection.java (with props)
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/SerializationOfReferenceCollection.java (with props)
Removed:
river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/loader/pref/PCodeSource.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/DelegateReflectionSecurityManager.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceQueueProcessor.java
Modified:
river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/ConcurrentPolicyFile.java
river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/DynamicPolicyProvider.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/delegates/DelegatePermission.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/CertificateGrant.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/DelegateCombinerSecurityManager.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/Deny.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/PermissionGrantBuilder.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/security/dos/IsolatedExecutor.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/CollectionWrapper.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/EntryFacadeConverter.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/RC.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingDeque.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingQueue.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceCollection.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceComparator.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentMap.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentNavigableMap.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceDeque.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceEntryFacade.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceFactory.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceIterator.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceList.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceMap.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceNavigableMap.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceNavigableSet.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceProcessor.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceSet.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceSortedMap.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceSortedSet.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferencedQueue.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/SoftIdentityReferenceKey.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/SoftReferenceKey.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/StrongReferenceKey.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/WeakIdentityReferenceKey.java
river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/WeakReferenceKey.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ConcurrentReferenceMapTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceBlockingQueueTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceCollectionTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceConcurrentNavigableMapTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceDequeTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceListTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceMapTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceNavigableMapTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceNavigableSetTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceSetTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceSortedMapTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferenceSortedSetTest.java
river/jtsk/skunk/peterConcurrentPolicy/test/src/org/apache/river/impl/util/ReferencedQueueTest.java
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/ConcurrentPolicyFile.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/ConcurrentPolicyFile.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/ConcurrentPolicyFile.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/ConcurrentPolicyFile.java Sun Oct 9 02:13:59 2011
@@ -58,6 +58,7 @@ import org.apache.river.impl.security.po
import org.apache.river.impl.security.policy.util.PolicyUtils;
import org.apache.river.impl.util.Ref;
import org.apache.river.impl.util.RC;
+import org.apache.river.impl.util.Referrer;
/**
@@ -214,11 +215,11 @@ public class ConcurrentPolicyFile extend
rl = rwl.readLock();
wl = rwl.writeLock();
grants = new HashSet<PermissionGrant>(120);
- ConcurrentMap<Reference<Object>, Reference<Collection<Permission>>> cacheInternal
- = new ConcurrentHashMap<Reference<Object>, Reference<Collection<Permission>>>(120);
+ ConcurrentMap<Referrer<Object>, Referrer<Collection<Permission>>> cacheInternal
+ = new ConcurrentHashMap<Referrer<Object>, Referrer<Collection<Permission>>>(120);
cache = RC.concurrentMap(cacheInternal, Ref.WEAK_IDENTITY, Ref.SOFT);
- ConcurrentMap<Reference<ProtectionDomain>, Reference<PermissionCollection>> impInternal
- = new ConcurrentHashMap<Reference<ProtectionDomain>, Reference<PermissionCollection>>(80);
+ ConcurrentMap<Referrer<ProtectionDomain>, Referrer<PermissionCollection>> impInternal
+ = new ConcurrentHashMap<Referrer<ProtectionDomain>, Referrer<PermissionCollection>>(80);
impliesCache = RC.concurrentMap(impInternal, Ref.WEAK_IDENTITY, Ref.SOFT);
/*
* The bootstrap policy makes implies decisions until this constructor
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/DynamicPolicyProvider.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/DynamicPolicyProvider.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/DynamicPolicyProvider.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/net/jini/security/policy/DynamicPolicyProvider.java Sun Oct 9 02:13:59 2011
@@ -57,6 +57,7 @@ import org.apache.river.impl.security.po
import org.apache.river.impl.util.CollectionsConcurrent;
import org.apache.river.impl.util.RC;
import org.apache.river.impl.util.Ref;
+import org.apache.river.impl.util.Referrer;
/**
* Security policy provider that supports dynamic granting of permissions at
@@ -270,11 +271,11 @@ public class DynamicPolicyProvider exten
* referenced, in the case where the client hangs onto objects
* recieved from it.
*/
- ConcurrentMap<Reference<ProtectionDomain>, Reference<PermissionCollection>> internal
- = new ConcurrentHashMap<Reference<ProtectionDomain>,Reference<PermissionCollection>>(120);
+ ConcurrentMap<Referrer<ProtectionDomain>, Referrer<PermissionCollection>> internal
+ = new ConcurrentHashMap<Referrer<ProtectionDomain>,Referrer<PermissionCollection>>(120);
cache = RC.concurrentMap(internal, Ref.WEAK_IDENTITY, Ref.SOFT);
- ConcurrentMap<Reference<PermissionGrant>, Reference<Permission[]>> gInternal
- = new ConcurrentHashMap<Reference<PermissionGrant>, Reference<Permission[]>>(60);
+ ConcurrentMap<Referrer<PermissionGrant>, Referrer<Permission[]>> gInternal
+ = new ConcurrentHashMap<Referrer<PermissionGrant>, Referrer<Permission[]>>(60);
grantCache = RC.concurrentMap(gInternal, Ref.WEAK, Ref.STRONG);
loggable = logger.isLoggable(Level.FINEST);
grantLock = new Object();
@@ -315,11 +316,11 @@ public class DynamicPolicyProvider exten
dynamicPolicyGrants = CollectionsConcurrent.multiReadCollection(
new ArrayList<PermissionGrant>(120));
remotePolicyGrants = new PermissionGrant[0];
- ConcurrentMap<Reference<ProtectionDomain>, Reference<PermissionCollection>> internal
- = new ConcurrentHashMap<Reference<ProtectionDomain>,Reference<PermissionCollection>>(120);
+ ConcurrentMap<Referrer<ProtectionDomain>, Referrer<PermissionCollection>> internal
+ = new ConcurrentHashMap<Referrer<ProtectionDomain>,Referrer<PermissionCollection>>(120);
cache = RC.concurrentMap(internal, Ref.WEAK_IDENTITY, Ref.SOFT);
- ConcurrentMap<Reference<PermissionGrant>, Reference<Permission[]>> gInternal
- = new ConcurrentHashMap<Reference<PermissionGrant>, Reference<Permission[]>>(60);
+ ConcurrentMap<Referrer<PermissionGrant>, Referrer<Permission[]>> gInternal
+ = new ConcurrentHashMap<Referrer<PermissionGrant>, Referrer<Permission[]>>(60);
grantCache = RC.concurrentMap(gInternal, Ref.WEAK, Ref.STRONG);
loggable = logger.isLoggable(Level.FINEST);
grantLock = new Object();
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/delegates/DelegatePermission.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/delegates/DelegatePermission.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/delegates/DelegatePermission.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/delegates/DelegatePermission.java Sun Oct 9 02:13:59 2011
@@ -36,6 +36,7 @@ import java.util.concurrent.ConcurrentMa
import org.apache.river.api.security.DelegateSecurityManager;
import org.apache.river.impl.util.RC;
import org.apache.river.impl.util.Ref;
+import org.apache.river.impl.util.Referrer;
/**
* A DelegatePermission represents any another Permission, called the candidate.
@@ -90,8 +91,8 @@ public final class DelegatePermission ex
*/
private static final ConcurrentMap<Permission,DelegatePermission> instances
= RC.concurrentMap(
- new ConcurrentHashMap<Reference<Permission>,
- Reference<DelegatePermission>>(120),
+ new ConcurrentHashMap<Referrer<Permission>,
+ Referrer<DelegatePermission>>(120),
Ref.WEAK, Ref.SOFT
);
/**
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/CertificateGrant.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/CertificateGrant.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/CertificateGrant.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/CertificateGrant.java Sun Oct 9 02:13:59 2011
@@ -127,7 +127,7 @@ class CertificateGrant extends Principal
public PermissionGrantBuilder getBuilderTemplate() {
PermissionGrantBuilder pgb = super.getBuilderTemplate();
return pgb.certificates(certs.toArray(new Certificate[certs.size()]))
- .exclude(exclusion)
+ //.exclude(exclusion)
.context(PermissionGrantBuilder.CODESOURCE_CERTS);
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/DelegateCombinerSecurityManager.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/DelegateCombinerSecurityManager.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/DelegateCombinerSecurityManager.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/DelegateCombinerSecurityManager.java Sun Oct 9 02:13:59 2011
@@ -38,6 +38,7 @@ import org.apache.river.api.delegates.De
import org.apache.river.impl.util.CollectionsConcurrent;
import org.apache.river.impl.util.RC;
import org.apache.river.impl.util.Ref;
+import org.apache.river.impl.util.Referrer;
/**
* DelegateCombinerSecurityManager, is intended to be a high performance
@@ -59,14 +60,14 @@ extends SecurityManager implements Deleg
public DelegateCombinerSecurityManager(){
super();
dc = new DelegateDomainCombiner();
- ConcurrentMap<Reference<AccessControlContext>,
- Reference<AccessControlContext>> internal =
- new ConcurrentHashMap<Reference<AccessControlContext>,
- Reference<AccessControlContext>>(100);
+ ConcurrentMap<Referrer<AccessControlContext>,
+ Referrer<AccessControlContext>> internal =
+ new ConcurrentHashMap<Referrer<AccessControlContext>,
+ Referrer<AccessControlContext>>(100);
contextCache = RC.concurrentMap(internal, Ref.SOFT, Ref.STRONG);
- ConcurrentMap<Reference<AccessControlContext>, Reference<Set<Permission>>> refmap
- = new ConcurrentHashMap<Reference<AccessControlContext>,
- Reference<Set<Permission>>>(100);
+ ConcurrentMap<Referrer<AccessControlContext>, Referrer<Set<Permission>>> refmap
+ = new ConcurrentHashMap<Referrer<AccessControlContext>,
+ Referrer<Set<Permission>>>(100);
checked = RC.concurrentMap(refmap, Ref.SOFT, Ref.STRONG);
g = new RevokePermission();
action = new Action();
@@ -80,7 +81,7 @@ extends SecurityManager implements Deleg
// Checks if Permission has already been checked for this context.
Set<Permission> checkedPerms = checked.get(executionContext);
if (checkedPerms == null){
- Set<Reference<Permission>> internal = new HashSet<Reference<Permission>>(96);
+ Set<Referrer<Permission>> internal = new HashSet<Referrer<Permission>>(96);
checkedPerms = CollectionsConcurrent.multiReadSet(RC.set(internal, Ref.SOFT));
Set<Permission> existed = checked.putIfAbsent(executionContext, checkedPerms);
if (existed != null) checkedPerms = existed;
@@ -167,8 +168,8 @@ extends SecurityManager implements Deleg
// create any more than abolutely necessary.
private final ConcurrentMap<ProtectionDomain,DelegateProtectionDomain> cache;
private DelegateDomainCombiner (){
- ConcurrentMap<Reference<ProtectionDomain>,Reference<DelegateProtectionDomain>> internal =
- new ConcurrentHashMap<Reference<ProtectionDomain>,Reference<DelegateProtectionDomain>>(120);
+ ConcurrentMap<Referrer<ProtectionDomain>,Referrer<DelegateProtectionDomain>> internal =
+ new ConcurrentHashMap<Referrer<ProtectionDomain>,Referrer<DelegateProtectionDomain>>(120);
cache = RC.concurrentMap(internal, Ref.WEAK_IDENTITY, Ref.STRONG);
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/Deny.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/Deny.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/Deny.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/Deny.java Sun Oct 9 02:13:59 2011
@@ -55,7 +55,7 @@ import org.apache.river.impl.security.po
*
* @author Peter Firmstone
*/
-public final class Deny implements Exclusion, Serializable {
+final class Deny implements Exclusion, Serializable {
private static final long serialVersionUID = 1L;
private final List<URL> uri;
private final List<CodeSource> code;
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/PermissionGrantBuilder.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/PermissionGrantBuilder.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/PermissionGrantBuilder.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/api/security/PermissionGrantBuilder.java Sun Oct 9 02:13:59 2011
@@ -139,12 +139,15 @@ public abstract class PermissionGrantBui
* EG: I trust code signed by XXX, but they have a security vulnerability
* in xxx.jar
*
+ * A better implementation would be to use a deny policy, where exclusions
+ * are checked before grants are checked.
+ *
* In the default implementation, this doesn't apply to Principal only
* grants, only Certificate and ClassLoader based grants.
* @param e
* @return
*/
- public abstract PermissionGrantBuilder exclude(Exclusion e);
+ //public abstract PermissionGrantBuilder exclude(Exclusion e);
/**
* Build the PermissionGrant using information supplied.
* @return an appropriate PermissionGrant.
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/security/dos/IsolatedExecutor.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/security/dos/IsolatedExecutor.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/security/dos/IsolatedExecutor.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/security/dos/IsolatedExecutor.java Sun Oct 9 02:13:59 2011
@@ -18,7 +18,6 @@
package org.apache.river.impl.security.dos;
-import java.lang.ref.Reference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@@ -40,6 +39,7 @@ import java.util.concurrent.locks.ReadWr
import java.util.concurrent.locks.ReentrantReadWriteLock;
import org.apache.river.impl.util.Ref;
import org.apache.river.impl.util.RC;
+import org.apache.river.impl.util.Referrer;
/**
* Performs Callable tasks in an isolated thread, which is terminated
@@ -80,7 +80,7 @@ public class IsolatedExecutor<T> impleme
state = State.RUNNING;
policy = new AbortPolicy();
factory = new Factory();
- failedTasks = RC.list(new ArrayList<Reference<Runnable>>(),Ref.SOFT);
+ failedTasks = RC.list(new ArrayList<Referrer<Runnable>>(),Ref.SOFT);
nullExec = new NullExecutor(); // Can't create one lazily if memory low.
isolateExecutor = new Executor(0, 1,
60L, TimeUnit.SECONDS,
Added: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/AbstractSerializationOfRC.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/AbstractSerializationOfRC.java?rev=1180519&view=auto
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/AbstractSerializationOfRC.java (added)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/AbstractSerializationOfRC.java Sun Oct 9 02:13:59 2011
@@ -0,0 +1,606 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.river.impl.util;
+
+import java.io.IOException;
+import java.io.InvalidClassException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.NavigableSet;
+import java.util.Queue;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.concurrent.BlockingDeque;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ *
+ * @author Peter Firmstone.
+ */
+abstract class AbstractSerializationOfRC<T> extends SerializationOfReferenceCollection<T>
+implements Serializable, List<T>, Set<T>, SortedSet<T>, NavigableSet<T> ,
+Queue<T>, Deque<T>, BlockingQueue<T>, BlockingDeque<T>{
+ private static final long serialVersionUID = 1L;
+
+ // This abstract class must not hold any serial data.
+
+ // Builder created List on deserialization
+ private volatile transient Collection<T> serialBuilt = null;
+ private volatile transient boolean built = false;
+
+
+ @Override
+ Collection<T> build() throws InstantiationException, IllegalAccessException {
+ if (isBuilt()) return getSerialBuilt();
+ setBuilt();
+ /* Traverse Inheritance heirarchy in reverse order */
+ if ( getClazz().isAssignableFrom(BlockingDeque.class))
+ return RC.blockingDeque((BlockingDeque<Referrer<T>>) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(BlockingQueue.class))
+ return RC.blockingQueue((BlockingQueue<Referrer<T>>) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(Deque.class))
+ return RC.deque((Deque<Referrer<T>>) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(Queue.class))
+ return RC.queue((Queue<Referrer<T>>) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(List.class) )
+ return RC.list((List<Referrer<T>> ) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(NavigableSet.class) )
+ return RC.navigableSet((NavigableSet<Referrer<T>>) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(SortedSet.class) )
+ return RC.sortedSet((SortedSet<Referrer<T>>) getCollection(), getType());
+ if ( getClazz().isAssignableFrom(Set.class))
+ return RC.set((Set<Referrer<T>>) getCollection(), getType());
+ return RC.collection(getCollection(), getType());
+ }
+
+ /**
+ * @serialData
+ * @return the type
+ */
+ public abstract Ref getType();
+
+ /**
+ * @serialData
+ * @return the collection
+ */
+ public abstract Collection<Referrer<T>> getCollection();
+
+ /**
+ * @serialData
+ * @return the class
+ */
+ public abstract Class getClazz();
+
+ /**
+ * @return the serialBuilt
+ */
+ public Collection<T> getSerialBuilt() {
+ return serialBuilt;
+ }
+
+ /**
+ * @param serialBuilt the serialBuilt to set
+ */
+ public Collection<T> setSerialBuilt(Collection<T> serialBuilt) {
+ this.serialBuilt = serialBuilt;
+ return serialBuilt;
+ }
+
+ /**
+ * @return the built
+ */
+ public boolean isBuilt() {
+ return built;
+ }
+
+ /**
+ *
+ */
+ public void setBuilt() {
+ built = true;
+ }
+
+
+ @Override
+ public int hashCode() {
+ if ( getSerialBuilt() instanceof List || getSerialBuilt() instanceof Set ){
+ return getSerialBuilt().hashCode();
+ }
+ return System.identityHashCode(this);
+ }
+
+ /**
+ * Because equals and hashCode are not defined for collections, we
+ * cannot guarantee consistent behaviour by implementing equals and
+ * hashCode. A collection could be a list, set, queue or deque.
+ * So a List != Queue and a Set != list. therefore equals for collections is
+ * not defined.
+ *
+ * However since two collections may both also be Lists, while abstracted
+ * from the client two lists may still be equal.
+ *
+ * Unfortunately this object, when behaving as a delegate, is not always
+ * equal to the object it is trying to represent.
+ *
+ * @see Collection#equals(java.lang.Object)
+ */
+
+ @Override
+ public boolean equals(Object o){
+ if ( o == this ) return true;
+ if ( getSerialBuilt() instanceof List || getSerialBuilt() instanceof Set ){
+ return getSerialBuilt().equals(o);
+ }
+ return false;
+ }
+
+ @Override
+ public Iterator<T> iterator(){
+ if (getSerialBuilt() != null) return getSerialBuilt().iterator();
+ return new NullIterator<T>();
+ }
+
+ @Override
+ public int size() {
+ if (getSerialBuilt() != null) return getSerialBuilt().size();
+ return 0;
+ }
+
+ public boolean add(T t){
+ if (getSerialBuilt() != null) return getSerialBuilt().add(t);
+ return false;
+ }
+
+ private void readObject(ObjectInputStream in)
+ throws IOException, ClassNotFoundException {
+ in.defaultReadObject();
+ }
+
+ private void writeObject(ObjectOutputStream out) throws IOException {
+ out.defaultWriteObject();
+ }
+
+ // If deserialized state may have changed since, if another type of
+ // Map, apart from ImmutableMap, uses the same builder for example.
+ final Object writeReplace() {
+ if ( isBuilt()) return getSerialBuilt();
+ return this;
+ }
+
+ final Object readResolve() throws ObjectStreamException{
+ try {
+ return setSerialBuilt(build());
+ } catch (InstantiationException ex) {
+ throw new InvalidClassException(this.getClass().toString(), ex.fillInStackTrace().toString());
+ } catch (IllegalAccessException ex) {
+ throw new InvalidClassException(this.getClass().toString(), ex.fillInStackTrace().toString());
+ }
+ }
+
+
+ public boolean addAll(int index, Collection<? extends T> c) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).addAll(index, c);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T get(int index) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).get(index);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T set(int index, T element) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).set(index, element);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void add(int index, T element) {
+ if (getSerialBuilt() instanceof List)((List<T>) getSerialBuilt()).add(index, element);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T remove(int index) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).remove(index);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public int indexOf(Object o) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).indexOf(o);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public int lastIndexOf(Object o) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).lastIndexOf(o);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public ListIterator<T> listIterator() {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).listIterator();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public ListIterator<T> listIterator(int index) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).listIterator(index);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public List<T> subList(int fromIndex, int toIndex) {
+ if (getSerialBuilt() instanceof List) return ((List<T>) getSerialBuilt()).subList(fromIndex, toIndex);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public Comparator<? super T> comparator() {
+ if (getSerialBuilt() instanceof SortedSet) return ((SortedSet<T>) getSerialBuilt()).comparator();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public SortedSet<T> subSet(T fromElement, T toElement) {
+ if (getSerialBuilt() instanceof SortedSet) return ((SortedSet<T>) getSerialBuilt()).subSet(fromElement, toElement);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public SortedSet<T> headSet(T toElement) {
+ if (getSerialBuilt() instanceof SortedSet) return ((SortedSet<T>) getSerialBuilt()).headSet(toElement);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public SortedSet<T> tailSet(T fromElement) {
+ if (getSerialBuilt() instanceof SortedSet) return ((SortedSet<T>) getSerialBuilt()).tailSet(fromElement);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T first() {
+ if (getSerialBuilt() instanceof SortedSet) return ((SortedSet<T>) getSerialBuilt()).first();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T last() {
+ if (getSerialBuilt() instanceof SortedSet)
+ return ((SortedSet<T>) getSerialBuilt()).last();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T lower(T e) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).lower(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T floor(T e) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).floor(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T ceiling(T e) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).ceiling(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T higher(T e) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).higher(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T pollFirst() {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).pollFirst();
+ if (getSerialBuilt() instanceof Deque)
+ return ((Deque<T>) getSerialBuilt()).pollFirst();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T pollLast() {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).pollLast();
+ if (getSerialBuilt() instanceof Deque)
+ return ((Deque<T>) getSerialBuilt()).pollLast();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public NavigableSet<T> descendingSet() {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).descendingSet();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public Iterator<T> descendingIterator() {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).descendingIterator();
+ if (getSerialBuilt() instanceof Deque)
+ return ((Deque<T>) getSerialBuilt()).descendingIterator();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public NavigableSet<T> subSet(T fromElement, boolean fromInclusive, T toElement, boolean toInclusive) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).subSet(fromElement, fromInclusive, toElement, toInclusive);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public NavigableSet<T> headSet(T toElement, boolean inclusive) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).headSet(toElement, inclusive);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public NavigableSet<T> tailSet(T fromElement, boolean inclusive) {
+ if (getSerialBuilt() instanceof NavigableSet)
+ return ((NavigableSet<T>) getSerialBuilt()).tailSet(fromElement, inclusive);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean offer(T e) {
+ if (getSerialBuilt() instanceof Queue) return ((Queue<T>) getSerialBuilt()).offer(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T remove() {
+ if (getSerialBuilt() instanceof Queue) return ((Queue<T>) getSerialBuilt()).remove();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T poll() {
+ if (getSerialBuilt() instanceof Queue) return ((Queue<T>) getSerialBuilt()).poll();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T element() {
+ if (getSerialBuilt() instanceof Queue) return ((Queue<T>) getSerialBuilt()).element();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T peek() {
+ if (getSerialBuilt() instanceof Queue) return ((Queue<T>) getSerialBuilt()).peek();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void addFirst(T e) {
+ if (getSerialBuilt() instanceof Deque) ((Deque<T>) getSerialBuilt()).addFirst(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void addLast(T e) {
+ if (getSerialBuilt() instanceof Deque) ((Deque<T>) getSerialBuilt()).addLast(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean offerFirst(T e) {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).offerFirst(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean offerLast(T e) {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).offerLast(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T removeFirst() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).removeFirst();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T removeLast() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).removeLast();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T getFirst() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).getFirst();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T getLast() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).getLast();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T peekFirst() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).peekFirst();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T peekLast() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).peekLast();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean removeFirstOccurrence(Object o) {
+ if (getSerialBuilt() instanceof Deque)
+ return ((Deque<T>) getSerialBuilt()).removeFirstOccurrence(o);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean removeLastOccurrence(Object o) {
+ if (getSerialBuilt() instanceof Deque)
+ return ((Deque<T>) getSerialBuilt()).removeLastOccurrence(o);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void push(T e) {
+ if (getSerialBuilt() instanceof Deque)((Deque<T>) getSerialBuilt()).push(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T pop() {
+ if (getSerialBuilt() instanceof Deque) return ((Deque<T>) getSerialBuilt()).pop();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void put(T e) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingQueue) ((BlockingQueue<T>) getSerialBuilt()).put(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean offer(T e, long timeout, TimeUnit unit) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingQueue)
+ return ((BlockingQueue<T>) getSerialBuilt()).offer(e, timeout, unit);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T take() throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingQueue)
+ return ((BlockingQueue<T>) getSerialBuilt()).take();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T poll(long timeout, TimeUnit unit) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingQueue)
+ return ((BlockingQueue<T>) getSerialBuilt()).poll(timeout, unit);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public int remainingCapacity() {
+ if (getSerialBuilt() instanceof BlockingQueue)
+ return ((BlockingQueue<T>) getSerialBuilt()).remainingCapacity();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public int drainTo(Collection<? super T> c) {
+ if (getSerialBuilt() instanceof BlockingQueue)
+ return ((BlockingQueue<T>) getSerialBuilt()).drainTo(c);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public int drainTo(Collection<? super T> c, int maxElements) {
+ if (getSerialBuilt() instanceof BlockingQueue)
+ return ((BlockingQueue<T>) getSerialBuilt()).drainTo(c, maxElements);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void putFirst(T e) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ ((BlockingDeque<T>) getSerialBuilt()).putFirst(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public void putLast(T e) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ ((BlockingDeque<T>) getSerialBuilt()).putLast(e);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean offerFirst(T e, long timeout, TimeUnit unit) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ return ((BlockingDeque<T>) getSerialBuilt()).offerFirst(e, timeout, unit);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public boolean offerLast(T e, long timeout, TimeUnit unit) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ return ((BlockingDeque<T>) getSerialBuilt()).offerLast(e, timeout, unit);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T takeFirst() throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ return ((BlockingDeque<T>) getSerialBuilt()).takeFirst();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T takeLast() throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ return ((BlockingDeque<T>) getSerialBuilt()).takeLast();
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T pollFirst(long timeout, TimeUnit unit) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ return ((BlockingDeque<T>) getSerialBuilt()).pollFirst(timeout, unit);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+ public T pollLast(long timeout, TimeUnit unit) throws InterruptedException {
+ if (getSerialBuilt() instanceof BlockingDeque)
+ return ((BlockingDeque<T>) getSerialBuilt()).pollLast(timeout, unit);
+ throw new UnsupportedOperationException("Unsupported Interface Method.");
+ }
+
+
+}
Propchange: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/AbstractSerializationOfRC.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/CollectionWrapper.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/CollectionWrapper.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/CollectionWrapper.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/CollectionWrapper.java Sun Oct 9 02:13:59 2011
@@ -27,19 +27,19 @@ import java.util.Iterator;
*
* @author peter
*/
-public class CollectionWrapper<T> extends AbstractCollection<Reference<T>> implements Collection<Reference<T>> {
+public class CollectionWrapper<T> extends AbstractCollection<Referrer<T>> implements Collection<Referrer<T>> {
private final Collection<T> col;
- private final ReferenceQueuingFactory<T, Reference<T>> rqf;
+ private final ReferenceQueuingFactory<T, Referrer<T>> rqf;
private final boolean enque;
- CollectionWrapper(Collection<T> col, ReferenceQueuingFactory<T, Reference<T>> rqf, boolean enque){
+ CollectionWrapper(Collection<T> col, ReferenceQueuingFactory<T, Referrer<T>> rqf, boolean enque){
this.col = col;
this.rqf = rqf;
this.enque = enque;
}
@Override
- public Iterator<Reference<T>> iterator() {
+ public Iterator<Referrer<T>> iterator() {
return new Iter<T>(col.iterator(), rqf);
}
@@ -48,14 +48,14 @@ public class CollectionWrapper<T> extend
return col.size();
}
- public boolean add(Reference<T> t) {
+ public boolean add(Referrer<T> t) {
return col.add( t != null ? t.get() : null );
}
- private class Iter<T> implements Iterator<Reference<T>> {
+ private class Iter<T> implements Iterator<Referrer<T>> {
Iterator<T> iterator;
- private final ReferenceQueuingFactory<T, Reference<T>> rqf;
- Iter(Iterator<T> it, ReferenceQueuingFactory<T, Reference<T>> rqf){
+ private final ReferenceQueuingFactory<T, Referrer<T>> rqf;
+ Iter(Iterator<T> it, ReferenceQueuingFactory<T, Referrer<T>> rqf){
iterator = it;
this.rqf = rqf;
}
@@ -66,7 +66,7 @@ public class CollectionWrapper<T> extend
}
@Override
- public Reference<T> next() {
+ public Referrer<T> next() {
return rqf.referenced( iterator.next(), enque);
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/EntryFacadeConverter.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/EntryFacadeConverter.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/EntryFacadeConverter.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/EntryFacadeConverter.java Sun Oct 9 02:13:59 2011
@@ -27,23 +27,23 @@ import java.util.Map.Entry;
*
* @author Peter Firmstone.
*/
-class EntryFacadeConverter<K,V> implements ReferenceQueuingFactory<Entry<K,V>, Entry<Reference<K>, Reference<V>>> {
- private final ReferenceQueuingFactory<K, Reference<K>> krqf;
- private final ReferenceQueuingFactory<V, Reference<V>> vrqf;
+class EntryFacadeConverter<K,V> implements ReferenceQueuingFactory<Entry<K,V>, Entry<Referrer<K>, Referrer<V>>> {
+ private final ReferenceQueuingFactory<K, Referrer<K>> krqf;
+ private final ReferenceQueuingFactory<V, Referrer<V>> vrqf;
- EntryFacadeConverter(ReferenceQueuingFactory<K, Reference<K>> krqf, ReferenceQueuingFactory<V, Reference<V>> vrqf) {
+ EntryFacadeConverter(ReferenceQueuingFactory<K, Referrer<K>> krqf, ReferenceQueuingFactory<V, Referrer<V>> vrqf) {
this.krqf = krqf;
this.vrqf = vrqf;
}
- public Entry<K,V> pseudoReferent(Entry<Reference<K>, Reference<V>> u) {
+ public Entry<K,V> pseudoReferent(Entry<Referrer<K>, Referrer<V>> u) {
return new ReferenceEntryFacade<K, V>(u, vrqf);
}
- public Entry<Reference<K>, Reference<V>> referenced(Entry<K,V> w, boolean enque) {
- // The entry could alread by a Reference based Entry obscured by a facade.
- return new SimpleEntry<Reference<K>, Reference<V>>(
+ public Entry<Referrer<K>, Referrer<V>> referenced(Entry<K,V> w, boolean enque) {
+ // The entry could alread by a Referrer based Entry obscured by a facade.
+ return new SimpleEntry<Referrer<K>, Referrer<V>>(
krqf.referenced(w.getKey(), enque), vrqf.referenced(w.getValue(), enque)
);
}
Added: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/NullIterator.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/NullIterator.java?rev=1180519&view=auto
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/NullIterator.java (added)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/NullIterator.java Sun Oct 9 02:13:59 2011
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.river.impl.util;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ *
+ * @author peter
+ */
+public class NullIterator<T> implements Iterator<T> {
+ @Override
+ public boolean hasNext() {
+ return false;
+ }
+
+ @Override
+ public T next() {
+ throw new NoSuchElementException("Null Iterator");
+ }
+
+ @Override
+ public void remove() {
+ }
+
+}
Propchange: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/NullIterator.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/RC.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/RC.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/RC.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/RC.java Sun Oct 9 02:13:59 2011
@@ -142,7 +142,7 @@ public class RC {
* @param comparator
* @return
*/
- public static <T> Comparator<Reference<T>> comparator(Comparator<? super T> comparator){
+ public static <T> Comparator<Referrer<T>> comparator(Comparator<? super T> comparator){
return new ReferenceComparator<T>(comparator);
}
@@ -155,7 +155,7 @@ public class RC {
* @param type
* @return
*/
- public static <T> Collection<T> collection(Collection<Reference<T>> internal, Ref type){
+ public static <T> Collection<T> collection(Collection<Referrer<T>> internal, Ref type){
return new ReferenceCollection<T>(internal, type);
}
@@ -168,7 +168,7 @@ public class RC {
* @param type
* @return
*/
- public static <T> List<T> list(List<Reference<T>> internal, Ref type){
+ public static <T> List<T> list(List<Referrer<T>> internal, Ref type){
return new ReferenceList<T>(internal, type);
}
@@ -181,7 +181,7 @@ public class RC {
* @param type
* @return
*/
- public static <T> Set<T> set(Set<Reference<T>> internal, Ref type){
+ public static <T> Set<T> set(Set<Referrer<T>> internal, Ref type){
return new ReferenceSet<T>(internal, type);
}
/**
@@ -194,7 +194,7 @@ public class RC {
* @return
*/
public static <T> SortedSet<T> sortedSet(
- SortedSet<Reference<T>> internal, Ref type){
+ SortedSet<Referrer<T>> internal, Ref type){
return new ReferenceSortedSet<T>(internal, type);
}
/**
@@ -207,7 +207,7 @@ public class RC {
* @return
*/
public static <T> NavigableSet<T> navigableSet(
- NavigableSet<Reference<T>> internal, Ref type){
+ NavigableSet<Referrer<T>> internal, Ref type){
return new ReferenceNavigableSet<T>(internal, type);
}
/**
@@ -219,7 +219,7 @@ public class RC {
* @param type
* @return
*/
- public static <T> Queue<T> queue(Queue<Reference<T>> internal, Ref type){
+ public static <T> Queue<T> queue(Queue<Referrer<T>> internal, Ref type){
return new ReferencedQueue<T>(internal, type);
}
/**
@@ -231,7 +231,7 @@ public class RC {
* @param type
* @return
*/
- public static <T> Deque<T> deque(Deque<Reference<T>> internal, Ref type){
+ public static <T> Deque<T> deque(Deque<Referrer<T>> internal, Ref type){
return new ReferenceDeque<T>(internal, type);
}
/**
@@ -244,7 +244,7 @@ public class RC {
* @return
*/
public static <T> BlockingQueue<T> blockingQueue(
- BlockingQueue<Reference<T>> internal, Ref type){
+ BlockingQueue<Referrer<T>> internal, Ref type){
return new ReferenceBlockingQueue<T>(internal, type);
}
/**
@@ -257,7 +257,7 @@ public class RC {
* @return
*/
public static <T> BlockingDeque<T> blockingDeque(
- BlockingDeque<Reference<T>> internal, Ref type){
+ BlockingDeque<Referrer<T>> internal, Ref type){
return new ReferenceBlockingDeque<T>(internal, type);
}
/**
@@ -272,7 +272,7 @@ public class RC {
* @return
*/
public static <K, V> Map<K, V> map(
- Map<Reference<K>, Reference<V>> internal, Ref key, Ref value){
+ Map<Referrer<K>, Referrer<V>> internal, Ref key, Ref value){
return new ReferenceMap<K, V>(internal, key, value);
}
/**
@@ -287,11 +287,11 @@ public class RC {
* @return
*/
public static <K, V> SortedMap<K, V> sortedMap(
- SortedMap<Reference<K>, Reference<V>> internal, Ref key, Ref value){
+ SortedMap<Referrer<K>, Referrer<V>> internal, Ref key, Ref value){
return new ReferenceSortedMap<K, V>(internal, key, value);
}
/**
- * Wrap a NavigableMap for holding references so it appears as a NavigableMap
+ * Wrap a NavigableMap for holding Referrers so it appears as a NavigableMap
* containing referents.
*
* @param <K>
@@ -302,7 +302,7 @@ public class RC {
* @return
*/
public static <K, V> NavigableMap<K, V> navigableMap(
- NavigableMap<Reference<K>, Reference<V>> internal, Ref key, Ref value){
+ NavigableMap<Referrer<K>, Referrer<V>> internal, Ref key, Ref value){
return new ReferenceNavigableMap<K, V>(internal, key, value);
}
/**
@@ -317,7 +317,7 @@ public class RC {
* @return
*/
public static <K, V> ConcurrentMap<K, V> concurrentMap(
- ConcurrentMap<Reference<K>, Reference<V>> internal, Ref key, Ref value){
+ ConcurrentMap<Referrer<K>, Referrer<V>> internal, Ref key, Ref value){
return new ReferenceConcurrentMap<K, V>(internal, key, value);
}
@@ -333,7 +333,7 @@ public class RC {
* @return
*/
public static <K, V> ConcurrentNavigableMap<K, V> concurrentNavigableMap(
- ConcurrentNavigableMap<Reference<K>, Reference<V>> internal, Ref key, Ref value){
+ ConcurrentNavigableMap<Referrer<K>, Referrer<V>> internal, Ref key, Ref value){
return new ReferenceConcurrentNavigableMap<K, V>(internal, key, value);
}
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingDeque.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingDeque.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingDeque.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingDeque.java Sun Oct 9 02:13:59 2011
@@ -18,7 +18,8 @@
package org.apache.river.impl.util;
-import java.lang.ref.Reference;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
import java.util.Collection;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.TimeUnit;
@@ -28,46 +29,51 @@ import java.util.concurrent.TimeUnit;
* @author Peter Firmstone.
*/
class ReferenceBlockingDeque<T> extends ReferenceDeque<T> implements BlockingDeque<T>{
+ private static final long serialVersionUID = 1L;
- private final BlockingDeque<Reference<T>> deque;
+ private final BlockingDeque<Referrer<T>> deque;
- ReferenceBlockingDeque(BlockingDeque<Reference<T>> deque, Ref type){
+ ReferenceBlockingDeque(BlockingDeque<Referrer<T>> deque, Ref type){
super(deque, type);
this.deque = deque;
}
-
+
+ private void readObject(ObjectInputStream stream)
+ throws InvalidObjectException{
+ throw new InvalidObjectException("Builder required");
+ }
public void putFirst(T e) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
deque.putFirst(r);
}
public void putLast(T e) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
deque.putLast(r);
}
public boolean offerFirst(T e, long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
return deque.offerFirst(r, timeout, unit);
}
public boolean offerLast(T e, long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
return deque.offerLast(r, timeout, unit);
}
public T takeFirst() throws InterruptedException {
processQueue();
- Reference<T> t = deque.takeFirst();
+ Referrer<T> t = deque.takeFirst();
if ( t != null ) return t.get();
return null;
}
@@ -75,7 +81,7 @@ class ReferenceBlockingDeque<T> extends
public T takeLast() throws InterruptedException {
processQueue();
- Reference<T> t = deque.takeLast();
+ Referrer<T> t = deque.takeLast();
if ( t != null ) return t.get();
return null;
}
@@ -83,7 +89,7 @@ class ReferenceBlockingDeque<T> extends
public T pollFirst(long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> t = deque.pollFirst(timeout, unit);
+ Referrer<T> t = deque.pollFirst(timeout, unit);
if ( t != null ) return t.get();
return null;
}
@@ -91,7 +97,7 @@ class ReferenceBlockingDeque<T> extends
public T pollLast(long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> t = deque.pollLast(timeout, unit);
+ Referrer<T> t = deque.pollLast(timeout, unit);
if ( t != null ) return t.get();
return null;
}
@@ -99,21 +105,21 @@ class ReferenceBlockingDeque<T> extends
public void put(T e) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
deque.put(r);
}
public boolean offer(T e, long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
return deque.offer(r,timeout, unit);
}
public T take() throws InterruptedException {
processQueue();
- Reference<T> t = deque.take();
+ Referrer<T> t = deque.take();
if ( t != null ) return t.get();
return null;
}
@@ -121,7 +127,7 @@ class ReferenceBlockingDeque<T> extends
public T poll(long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> t = deque.poll(timeout, unit);
+ Referrer<T> t = deque.poll(timeout, unit);
if ( t != null ) return t.get();
return null;
}
@@ -137,7 +143,7 @@ class ReferenceBlockingDeque<T> extends
if (c == null) throw new NullPointerException();
if (c == this) throw new IllegalArgumentException();
@SuppressWarnings("unchecked")
- Collection<Reference<T>> dr = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
+ Collection<Referrer<T>> dr = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
return deque.drainTo(dr);
}
@@ -147,7 +153,7 @@ class ReferenceBlockingDeque<T> extends
if (c == null) throw new NullPointerException();
if (c == this) throw new IllegalArgumentException();
@SuppressWarnings("unchecked")
- Collection<Reference<T>> drain = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
+ Collection<Referrer<T>> drain = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
return deque.drainTo(drain, maxElements);
}
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingQueue.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingQueue.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingQueue.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceBlockingQueue.java Sun Oct 9 02:13:59 2011
@@ -18,7 +18,8 @@
package org.apache.river.impl.util;
-import java.lang.ref.Reference;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
import java.util.Collection;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
@@ -29,35 +30,41 @@ import java.util.concurrent.TimeUnit;
* @author Peter Firmstone.
*/
class ReferenceBlockingQueue<T> extends ReferencedQueue<T> implements BlockingQueue<T> {
- private final BlockingQueue<Reference<T>> queue;
+ private static final long serialVersionUID = 1L;
+ private final BlockingQueue<Referrer<T>> queue;
- ReferenceBlockingQueue(BlockingQueue<Reference<T>> queue, Ref type){
+ ReferenceBlockingQueue(BlockingQueue<Referrer<T>> queue, Ref type){
super(queue, type);
this.queue = queue;
}
+
+ private void readObject(ObjectInputStream stream)
+ throws InvalidObjectException{
+ throw new InvalidObjectException("Builder required");
+ }
public void put(T e) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
queue.put(r);
}
public boolean offer(T e, long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
return queue.offer(r, timeout, unit);
}
public T take() throws InterruptedException {
processQueue();
- Reference<T> t = queue.take();
+ Referrer<T> t = queue.take();
if ( t != null ) return t.get();
return null;
}
public T poll(long timeout, TimeUnit unit) throws InterruptedException {
processQueue();
- Reference<T> t = queue.poll(timeout, unit);
+ Referrer<T> t = queue.poll(timeout, unit);
if ( t != null ) return t.get();
return null;
}
@@ -72,7 +79,7 @@ class ReferenceBlockingQueue<T> extends
if (c == null) throw new NullPointerException();
if (c == this) throw new IllegalArgumentException();
@SuppressWarnings("unchecked")
- Collection<Reference<T>> dr = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
+ Collection<Referrer<T>> dr = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
return queue.drainTo(dr);
}
@@ -81,7 +88,7 @@ class ReferenceBlockingQueue<T> extends
if (c == null) throw new NullPointerException();
if (c == this) throw new IllegalArgumentException();
@SuppressWarnings("unchecked")
- Collection<Reference<T>> drain = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
+ Collection<Referrer<T>> drain = new CollectionWrapper<T>( (Collection<T>) c, getRQF(), true);
return queue.drainTo(drain, maxElements);
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceCollection.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceCollection.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceCollection.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceCollection.java Sun Oct 9 02:13:59 2011
@@ -18,13 +18,21 @@
package org.apache.river.impl.util;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+import java.io.WriteAbortedException;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.AbstractCollection;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
/**
* A Collection of Reference Objects, the developer may chose any Collection
@@ -49,16 +57,18 @@ import java.util.Set;
* @see ConcurrentCollections#multiReadCollection(java.util.Collection)
* @author Peter Firmstone.
*/
-class ReferenceCollection<T> extends AbstractCollection<T> implements Collection<T>{
- private final Collection<Reference<T>> col;
- private final ReferenceQueuingFactory<T, Reference<T>> rqf;
+class ReferenceCollection<T> extends AbstractCollection<T>
+ implements Collection<T>, Serializable {
+ private static final long serialVersionUID = 1L;
+ private final Collection<Referrer<T>> col;
+ private final ReferenceQueuingFactory<T, Referrer<T>> rqf;
- ReferenceCollection(Collection<Reference<T>> col, Ref type){
+ ReferenceCollection(Collection<Referrer<T>> col, Ref type){
this(col, new ReferenceProcessor<T>(col, type, type == Ref.STRONG ? null : new ReferenceQueue<T>()));
}
- ReferenceCollection(Collection<Reference<T>> col,
- ReferenceQueuingFactory<T, Reference<T>> rqf){
+ ReferenceCollection(Collection<Referrer<T>> col,
+ ReferenceQueuingFactory<T, Referrer<T>> rqf){
this.col = col;
this.rqf = rqf;
}
@@ -67,11 +77,11 @@ class ReferenceCollection<T> extends Abs
rqf.processQueue();
}
- ReferenceQueuingFactory<T, Reference<T>> getRQF(){
+ ReferenceQueuingFactory<T, Referrer<T>> getRQF(){
return rqf;
}
- Reference<T> wrapObj(T t, boolean enqueue){
+ Referrer<T> wrapObj(T t, boolean enqueue){
return rqf.referenced(t, enqueue);
}
@@ -166,4 +176,21 @@ class ReferenceCollection<T> extends Abs
}
return false;
}
+
+ final Object writeReplace() throws ObjectStreamException {
+ try {
+ // returns a Builder instead of this class.
+ return SerializationOfReferenceCollection.create(getClass(), col, Ref.SOFT);
+ } catch (InstantiationException ex) {
+ throw new WriteAbortedException("Unable to create serialization proxy", ex);
+ } catch (IllegalAccessException ex) {
+ throw new WriteAbortedException("Unable to create serialization proxy", ex);
+ }
+ }
+
+ private void readObject(ObjectInputStream stream)
+ throws InvalidObjectException{
+ throw new InvalidObjectException("Builder required");
+ }
+
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceComparator.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceComparator.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceComparator.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceComparator.java Sun Oct 9 02:13:59 2011
@@ -26,14 +26,14 @@ import java.util.Comparator;
* @param <T>
* @author Peter Firmstone.
*/
-class ReferenceComparator<T> implements Comparator<Reference<T>> {
+class ReferenceComparator<T> implements Comparator<Referrer<T>> {
private final Comparator<? super T> comparator;
ReferenceComparator(Comparator<? super T> comparator){
if ( comparator == null ) throw new IllegalArgumentException("Null value prohibited");
this.comparator = comparator;
}
- public int compare(Reference<T> o1, Reference<T> o2) {
+ public int compare(Referrer<T> o1, Referrer<T> o2) {
return comparator.compare( o1 != null ? o1.get() : null, o2 != null ? o2.get() : null);
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentMap.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentMap.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentMap.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentMap.java Sun Oct 9 02:13:59 2011
@@ -49,24 +49,24 @@ import java.util.concurrent.ConcurrentMa
class ReferenceConcurrentMap<K, V> extends ReferenceMap<K, V> implements ConcurrentMap<K, V> {
// ConcurrentMap must be protected from null values? It changes it's behaviour, is that a problem?
- private final ConcurrentMap<Reference<K>, Reference<V>> map;
+ private final ConcurrentMap<Referrer<K>, Referrer<V>> map;
- ReferenceConcurrentMap(ConcurrentMap<Reference<K>,Reference<V>> map, Ref key, Ref val){
+ ReferenceConcurrentMap(ConcurrentMap<Referrer<K>,Referrer<V>> map, Ref key, Ref val){
super (map, key, val);
this.map = map;
}
- ReferenceConcurrentMap(ConcurrentMap<Reference<K>, Reference<V>> map,
- ReferenceQueuingFactory<K, Reference<K>> krqf, ReferenceQueuingFactory<V, Reference<V>> vrqf){
+ ReferenceConcurrentMap(ConcurrentMap<Referrer<K>, Referrer<V>> map,
+ ReferenceQueuingFactory<K, Referrer<K>> krqf, ReferenceQueuingFactory<V, Referrer<V>> vrqf){
super(map, krqf, vrqf);
this.map = map;
}
public V putIfAbsent(K key, V value) {
processQueue(); //may be a slight delay before atomic putIfAbsent
- Reference<K> k = wrapKey(key, true);
- Reference<V> v = wrapVal(value, true);
- Reference<V> val = map.putIfAbsent(k, v);
+ Referrer<K> k = wrapKey(key, true);
+ Referrer<V> v = wrapVal(value, true);
+ Referrer<V> val = map.putIfAbsent(k, v);
while ( val != null ) {
V existed = val.get();
// We hold a strong reference to value, so
@@ -100,7 +100,7 @@ class ReferenceConcurrentMap<K, V> exten
public V replace(K key, V value) {
processQueue();
- Reference<V> val = map.replace(wrapKey(key, true), wrapVal(value, true));
+ Referrer<V> val = map.replace(wrapKey(key, true), wrapVal(value, true));
if ( val != null ) return val.get();
return null;
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentNavigableMap.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentNavigableMap.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentNavigableMap.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceConcurrentNavigableMap.java Sun Oct 9 02:13:59 2011
@@ -32,15 +32,15 @@ import java.util.concurrent.ConcurrentNa
*/
class ReferenceConcurrentNavigableMap<K,V>
extends ReferenceConcurrentMap<K,V> implements ConcurrentNavigableMap<K,V>{
- private final ConcurrentNavigableMap<Reference<K>,Reference<V>> map;
+ private final ConcurrentNavigableMap<Referrer<K>,Referrer<V>> map;
- ReferenceConcurrentNavigableMap(ConcurrentNavigableMap<Reference<K>, Reference<V>> map, Ref keyRef, Ref valRef){
+ ReferenceConcurrentNavigableMap(ConcurrentNavigableMap<Referrer<K>, Referrer<V>> map, Ref keyRef, Ref valRef){
super(map, keyRef, valRef);
this.map = map;
}
- ReferenceConcurrentNavigableMap(ConcurrentNavigableMap<Reference<K>, Reference<V>> map,
- ReferenceQueuingFactory<K, Reference<K>> krqf, ReferenceQueuingFactory<V, Reference<V>> vrqf){
+ ReferenceConcurrentNavigableMap(ConcurrentNavigableMap<Referrer<K>, Referrer<V>> map,
+ ReferenceQueuingFactory<K, Referrer<K>> krqf, ReferenceQueuingFactory<V, Referrer<V>> vrqf){
super(map, krqf, vrqf);
this.map = map;
}
@@ -138,7 +138,7 @@ extends ReferenceConcurrentMap<K,V> impl
public K lowerKey(K key) {
processQueue();
- Reference<K> k = map.lowerKey(wrapKey(key, false));
+ Referrer<K> k = map.lowerKey(wrapKey(key, false));
if ( k != null ) return k.get();
return null;
}
@@ -153,7 +153,7 @@ extends ReferenceConcurrentMap<K,V> impl
public K floorKey(K key) {
processQueue();
- Reference<K> k = map.floorKey(wrapKey(key, false));
+ Referrer<K> k = map.floorKey(wrapKey(key, false));
if ( k != null ) return k.get();
return null;
}
@@ -168,7 +168,7 @@ extends ReferenceConcurrentMap<K,V> impl
public K ceilingKey(K key) {
processQueue();
- Reference<K> k = map.ceilingKey(wrapKey(key, false));
+ Referrer<K> k = map.ceilingKey(wrapKey(key, false));
if ( k != null ) return k.get();
return null;
}
@@ -183,7 +183,7 @@ extends ReferenceConcurrentMap<K,V> impl
public K higherKey(K key) {
processQueue();
- Reference<K> k = map.higherKey(wrapKey(key, false));
+ Referrer<K> k = map.higherKey(wrapKey(key, false));
if ( k != null ) return k.get();
return null;
}
@@ -223,7 +223,7 @@ extends ReferenceConcurrentMap<K,V> impl
@SuppressWarnings("unchecked")
public Comparator<? super K> comparator() {
processQueue();
- Comparator<? super Reference<K>> c = map.comparator();
+ Comparator<? super Referrer<K>> c = map.comparator();
if ( c instanceof ReferenceComparator){
return ((ReferenceComparator) c).get();
}
@@ -232,14 +232,14 @@ extends ReferenceConcurrentMap<K,V> impl
public K firstKey() {
processQueue();
- Reference<K> k = map.firstKey();
+ Referrer<K> k = map.firstKey();
if ( k != null ) return k.get();
return null;
}
public K lastKey() {
processQueue();
- Reference<K> k = map.lastKey();
+ Referrer<K> k = map.lastKey();
if ( k != null ) return k.get();
return null;
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceDeque.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceDeque.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceDeque.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceDeque.java Sun Oct 9 02:13:59 2011
@@ -18,7 +18,8 @@
package org.apache.river.impl.util;
-import java.lang.ref.Reference;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
import java.util.Deque;
import java.util.Iterator;
@@ -27,87 +28,94 @@ import java.util.Iterator;
* @author Peter Firmstone
*/
class ReferenceDeque<T> extends ReferencedQueue<T> implements Deque<T>{
- private final Deque<Reference<T>> deque;
- ReferenceDeque(Deque<Reference<T>> deque, Ref type){
+ private static final long serialVersionUID = 1L;
+ private final Deque<Referrer<T>> deque;
+ ReferenceDeque(Deque<Referrer<T>> deque, Ref type){
super(deque, type);
this.deque = deque;
}
+
+ private void readObject(ObjectInputStream stream)
+ throws InvalidObjectException{
+ throw new InvalidObjectException("Builder required");
+ }
+
public void addFirst(T e) {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
deque.addFirst(r);
}
public void addLast(T e) {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
deque.addLast(r);
}
public boolean offerFirst(T e) {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
return deque.offerFirst(r);
}
public boolean offerLast(T e) {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
return deque.offerLast(r);
}
public T removeFirst() {
processQueue();
- Reference<T> t = deque.removeFirst();
+ Referrer<T> t = deque.removeFirst();
if ( t != null ) return t.get();
return null;
}
public T removeLast() {
processQueue();
- Reference<T> t = deque.removeLast();
+ Referrer<T> t = deque.removeLast();
if ( t != null ) return t.get();
return null;
}
public T pollFirst() {
processQueue();
- Reference<T> t = deque.pollFirst();
+ Referrer<T> t = deque.pollFirst();
if ( t != null ) return t.get();
return null;
}
public T pollLast() {
processQueue();
- Reference<T> t = deque.pollLast();
+ Referrer<T> t = deque.pollLast();
if ( t != null ) return t.get();
return null;
}
public T getFirst() {
processQueue();
- Reference<T> t = deque.getFirst();
+ Referrer<T> t = deque.getFirst();
if ( t != null ) return t.get();
return null;
}
public T getLast() {
processQueue();
- Reference<T> t = deque.getLast();
+ Referrer<T> t = deque.getLast();
if ( t != null ) return t.get();
return null;
}
public T peekFirst() {
processQueue();
- Reference<T> t = deque.peekFirst();
+ Referrer<T> t = deque.peekFirst();
if ( t != null ) return t.get();
return null;
}
public T peekLast() {
processQueue();
- Reference<T> t = deque.peekLast();
+ Referrer<T> t = deque.peekLast();
if ( t != null ) return t.get();
return null;
}
@@ -115,26 +123,26 @@ class ReferenceDeque<T> extends Referenc
public boolean removeFirstOccurrence(Object o) {
processQueue();
@SuppressWarnings("unchecked")
- Reference<T> r = wrapObj((T) o, false);
+ Referrer<T> r = wrapObj((T) o, false);
return deque.removeFirstOccurrence(r);
}
public boolean removeLastOccurrence(Object o) {
processQueue();
@SuppressWarnings("unchecked")
- Reference<T> r = wrapObj((T) o, false);
+ Referrer<T> r = wrapObj((T) o, false);
return deque.removeLastOccurrence(r);
}
public void push(T e) {
processQueue();
- Reference<T> r = wrapObj(e, true);
+ Referrer<T> r = wrapObj(e, true);
deque.push(r);
}
public T pop() {
processQueue();
- Reference<T> t = deque.pop();
+ Referrer<T> t = deque.pop();
if ( t != null ) return t.get();
return null;
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceEntryFacade.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceEntryFacade.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceEntryFacade.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceEntryFacade.java Sun Oct 9 02:13:59 2011
@@ -27,28 +27,28 @@ import java.util.Map.Entry;
* @author Peter Firmstone.
*/
class ReferenceEntryFacade<K, V> implements Map.Entry<K, V> {
- private final Entry<Reference<K>, Reference<V>> entry;
- private final ReferenceQueuingFactory<V, Reference<V>> rqf;
+ private final Entry<Referrer<K>, Referrer<V>> entry;
+ private final ReferenceQueuingFactory<V, Referrer<V>> rqf;
- ReferenceEntryFacade(Entry<Reference<K>, Reference<V>> entry, ReferenceQueuingFactory<V, Reference<V>> rqf){
+ ReferenceEntryFacade(Entry<Referrer<K>, Referrer<V>> entry, ReferenceQueuingFactory<V, Referrer<V>> rqf){
this.entry = entry;
this.rqf = rqf;
}
public K getKey() {
- Reference<K> k = entry.getKey();
+ Referrer<K> k = entry.getKey();
if ( k != null ) return k.get();
return null;
}
public V getValue() {
- Reference<V> v = entry.getValue();
+ Referrer<V> v = entry.getValue();
if ( v != null ) return v.get();
return null;
}
public V setValue(V value) {
- Reference<V> v = entry.setValue(wrapVal(value, true));
+ Referrer<V> v = entry.setValue(wrapVal(value, true));
if ( v != null ) return v.get();
return null;
}
@@ -79,7 +79,7 @@ class ReferenceEntryFacade<K, V> impleme
e1.getValue().equals(e2.getValue())));
}
- private Reference<V> wrapVal(V val, boolean enque) {
+ private Referrer<V> wrapVal(V val, boolean enque) {
return rqf.referenced(val, enque);
}
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceFactory.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceFactory.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceFactory.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceFactory.java Sun Oct 9 02:13:59 2011
@@ -38,7 +38,7 @@ class ReferenceFactory<T> {
// Non instantiable.
private ReferenceFactory(){}
- static <T> Reference<T> create(T t, ReferenceQueue<? super T> queue, Ref type ){
+ static <T> Referrer<T> create(T t, ReferenceQueue<? super T> queue, Ref type ){
switch (type){
case WEAK_IDENTITY: return new WeakIdentityReferenceKey<T>(t, queue);
case SOFT_IDENTITY: return new SoftIdentityReferenceKey<T>(t, queue);
Modified: river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceIterator.java
URL: http://svn.apache.org/viewvc/river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceIterator.java?rev=1180519&r1=1180518&r2=1180519&view=diff
==============================================================================
--- river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceIterator.java (original)
+++ river/jtsk/skunk/peterConcurrentPolicy/src/org/apache/river/impl/util/ReferenceIterator.java Sun Oct 9 02:13:59 2011
@@ -26,9 +26,9 @@ import java.util.Iterator;
* @author Peter Firmstone.
*/
class ReferenceIterator<T> implements Iterator<T> {
- private final Iterator<Reference<T>> iterator;
+ private final Iterator<Referrer<T>> iterator;
- ReferenceIterator(Iterator<Reference<T>> iterator) {
+ ReferenceIterator(Iterator<Referrer<T>> iterator) {
if ( iterator == null ) throw new IllegalArgumentException("iterator cannot be null");
this.iterator = iterator;
}
@@ -38,7 +38,7 @@ class ReferenceIterator<T> implements It
}
public T next() {
- Reference<T> t = iterator.next();
+ Referrer<T> t = iterator.next();
if ( t != null ) return t.get();
return null;
}