test/loops/RWMap.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 */
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;


/**
 * This is an incomplete implementation of a wrapper class
 * that places read-write locks around unsynchronized Maps.
 * Exists as a sample input for MapLoops test.
 */

public class RWMap implements Map {
    private final Map m;
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    
    public RWMap(Map m) {
        if (m == null)
            throw new NullPointerException();
        this.m = m;
    }

    public RWMap() { 
        this(new TreeMap()); // use TreeMap by default
        //        this(new IdentityHashMap()); 
    }

    public int size() {
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.size();} finally { l.unlock(); }
    }
    public boolean isEmpty(){
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.isEmpty();} finally { l.unlock(); }
    }

    public Object get(Object key) {
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.get(key);} finally { l.unlock(); }
    }

    public boolean containsKey(Object key) {
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.containsKey(key);} finally { l.unlock(); }
    }
    public boolean containsValue(Object value){
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.containsValue(value);} finally { l.unlock(); }
    }


    public Set keySet() { // Not implemented
        return m.keySet();
    }
    
    public Set entrySet() { // Not implemented
        return m.entrySet();
    }
    
    public Collection values() { // Not implemented
        return m.values();
    }
    
    public boolean equals(Object o) {
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.equals(o);} finally { l.unlock(); }
    }
    public int hashCode() {
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.hashCode();} finally { l.unlock(); }
    }
    public String toString() {
        ReentrantReadWriteLock.ReadLock l =  rwl.readLock();
        l.lock(); try {return m.toString();} finally { l.unlock(); }
    }


    public Object put(Object key, Object value) {
        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
        l.lock(); try {return m.put(key, value);} finally { l.unlock(); }
    }
    public Object remove(Object key) {
        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
        l.lock(); try {return m.remove(key);} finally { l.unlock(); }
    }
    public void putAll(Map map) {
        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
        l.lock(); try {m.putAll(map);} finally { l.unlock(); }
    }
    public void clear() {
        ReentrantReadWriteLock.WriteLock l =  rwl.writeLock();
        l.lock(); try {m.clear();} finally { l.unlock(); }
    }
    
}
Revision:	1.4
Committed:	Tue Oct 4 20:09:41 2005 UTC (18 years, 7 months ago) by dl
Branch:	MAIN
Changes since 1.3:	+24 -12 lines
Log Message:	Add collections tests
#	User	Rev	Content
1	dl	1.2	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/licenses/publicdomain
5			*/
6	dl	1.1	import java.util.*;
7			import java.util.concurrent.*;
8			import java.util.concurrent.locks.*;
9
10
11			/**
12			* This is an incomplete implementation of a wrapper class
13			* that places read-write locks around unsynchronized Maps.
14			* Exists as a sample input for MapLoops test.
15			*/
16
17			public class RWMap implements Map {
18			private final Map m;
19			private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
20
21			public RWMap(Map m) {
22			if (m == null)
23			throw new NullPointerException();
24			this.m = m;
25			}
26
27			public RWMap() {
28			this(new TreeMap()); // use TreeMap by default
29	dl	1.3	// this(new IdentityHashMap());
30	dl	1.1	}
31
32			public int size() {
33	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
34			l.lock(); try {return m.size();} finally { l.unlock(); }
35	dl	1.1	}
36			public boolean isEmpty(){
37	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
38			l.lock(); try {return m.isEmpty();} finally { l.unlock(); }
39	dl	1.1	}
40
41			public Object get(Object key) {
42	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
43			l.lock(); try {return m.get(key);} finally { l.unlock(); }
44	dl	1.1	}
45
46			public boolean containsKey(Object key) {
47	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
48			l.lock(); try {return m.containsKey(key);} finally { l.unlock(); }
49	dl	1.1	}
50			public boolean containsValue(Object value){
51	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
52			l.lock(); try {return m.containsValue(value);} finally { l.unlock(); }
53	dl	1.1	}
54
55
56			public Set keySet() { // Not implemented
57			return m.keySet();
58			}
59
60			public Set entrySet() { // Not implemented
61			return m.entrySet();
62			}
63
64			public Collection values() { // Not implemented
65			return m.values();
66			}
67
68			public boolean equals(Object o) {
69	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
70			l.lock(); try {return m.equals(o);} finally { l.unlock(); }
71	dl	1.1	}
72			public int hashCode() {
73	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
74			l.lock(); try {return m.hashCode();} finally { l.unlock(); }
75	dl	1.1	}
76			public String toString() {
77	dl	1.4	ReentrantReadWriteLock.ReadLock l = rwl.readLock();
78			l.lock(); try {return m.toString();} finally { l.unlock(); }
79	dl	1.1	}
80
81
82
83			public Object put(Object key, Object value) {
84	dl	1.4	ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
85			l.lock(); try {return m.put(key, value);} finally { l.unlock(); }
86	dl	1.1	}
87			public Object remove(Object key) {
88	dl	1.4	ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
89			l.lock(); try {return m.remove(key);} finally { l.unlock(); }
90	dl	1.1	}
91			public void putAll(Map map) {
92	dl	1.4	ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
93			l.lock(); try {m.putAll(map);} finally { l.unlock(); }
94	dl	1.1	}
95			public void clear() {
96	dl	1.4	ReentrantReadWriteLock.WriteLock l = rwl.writeLock();
97			l.lock(); try {m.clear();} finally { l.unlock(); }
98	dl	1.1	}
99
100			}