001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.cache;
016    
017    import java.io.Serializable;
018    
019    /**
020     * @author Tina Tian
021     */
022    public abstract class AbstractPortalCache<K extends Serializable, V>
023            implements LowLevelCache<K, V> {
024    
025            @Override
026            public V get(K key) {
027                    if (key == null) {
028                            throw new NullPointerException("Key is null");
029                    }
030    
031                    return doGet(key);
032            }
033    
034            @Override
035            public void put(K key, V value) {
036                    put(key, value, DEFAULT_TIME_TO_LIVE, false);
037            }
038    
039            @Override
040            public void put(K key, V value, int timeToLive) {
041                    put(key, value, timeToLive, false);
042            }
043    
044            @Override
045            public V putIfAbsent(K key, V value) {
046                    return putIfAbsent(key, value, DEFAULT_TIME_TO_LIVE);
047            }
048    
049            @Override
050            public V putIfAbsent(K key, V value, int timeToLive) {
051                    if (key == null) {
052                            throw new NullPointerException("Key is null");
053                    }
054    
055                    if (value == null) {
056                            throw new NullPointerException("Value is null");
057                    }
058    
059                    if (timeToLive < 0) {
060                            throw new IllegalArgumentException("Time to live is negative");
061                    }
062    
063                    return doPutIfAbsent(key, value, timeToLive);
064            }
065    
066            @Override
067            public void putQuiet(K key, V value) {
068                    put(key, value, DEFAULT_TIME_TO_LIVE, true);
069            }
070    
071            @Override
072            public void putQuiet(K key, V value, int timeToLive) {
073                    put(key, value, timeToLive, true);
074            }
075    
076            @Override
077            public void registerCacheListener(CacheListener<K, V> cacheListener) {
078                    aggregatedCacheListener.addCacheListener(cacheListener);
079            }
080    
081            @Override
082            public void registerCacheListener(
083                    CacheListener<K, V> cacheListener,
084                    CacheListenerScope cacheListenerScope) {
085    
086                    aggregatedCacheListener.addCacheListener(
087                            cacheListener, cacheListenerScope);
088            }
089    
090            @Override
091            public void remove(K key) {
092                    if (key == null) {
093                            throw new NullPointerException("Key is null");
094                    }
095    
096                    doRemove(key);
097            }
098    
099            @Override
100            public boolean remove(K key, V value) {
101                    if (key == null) {
102                            throw new NullPointerException("Key is null");
103                    }
104    
105                    if (value == null) {
106                            throw new NullPointerException("Value is null");
107                    }
108    
109                    return doRemove(key, value);
110            }
111    
112            @Override
113            public V replace(K key, V value) {
114                    return replace(key, value, DEFAULT_TIME_TO_LIVE);
115            }
116    
117            @Override
118            public V replace(K key, V value, int timeToLive) {
119                    if (key == null) {
120                            throw new NullPointerException("Key is null");
121                    }
122    
123                    if (value == null) {
124                            throw new NullPointerException("Value is null");
125                    }
126    
127                    if (timeToLive < 0) {
128                            throw new IllegalArgumentException("Time to live is negative");
129                    }
130    
131                    return doReplace(key, value, timeToLive);
132            }
133    
134            @Override
135            public boolean replace(K key, V oldValue, V newValue) {
136                    return replace(key, oldValue, newValue, DEFAULT_TIME_TO_LIVE);
137            }
138    
139            @Override
140            public boolean replace(K key, V oldValue, V newValue, int timeToLive) {
141                    if (key == null) {
142                            throw new NullPointerException("Key is null");
143                    }
144    
145                    if (oldValue == null) {
146                            throw new NullPointerException("Old value is null");
147                    }
148    
149                    if (newValue == null) {
150                            throw new NullPointerException("New value is null");
151                    }
152    
153                    if (timeToLive < 0) {
154                            throw new IllegalArgumentException("Time to live is negative");
155                    }
156    
157                    return doReplace(key, oldValue, newValue, timeToLive);
158            }
159    
160            @Override
161            public void unregisterCacheListener(CacheListener<K, V> cacheListener) {
162                    aggregatedCacheListener.removeCacheListener(cacheListener);
163            }
164    
165            @Override
166            public void unregisterCacheListeners() {
167                    aggregatedCacheListener.clearAll();
168            }
169    
170            protected abstract V doGet(K key);
171    
172            protected abstract void doPut(
173                    K key, V value, int timeToLive, boolean quiet);
174    
175            protected abstract V doPutIfAbsent(K key, V value, int timeToLive);
176    
177            protected abstract void doRemove(K key);
178    
179            protected abstract boolean doRemove(K key, V value);
180    
181            protected abstract V doReplace(K key, V value, int timeToLive);
182    
183            protected abstract boolean doReplace(
184                    K key, V oldValue, V newValue, int timeToLive);
185    
186            protected void put(K key, V value, int timeToLive, boolean quiet) {
187                    if (key == null) {
188                            throw new NullPointerException("Key is null");
189                    }
190    
191                    if (value == null) {
192                            throw new NullPointerException("Value is null");
193                    }
194    
195                    if (timeToLive < 0) {
196                            throw new IllegalArgumentException("Time to live is negative");
197                    }
198    
199                    doPut(key, value, timeToLive, quiet);
200            }
201    
202            protected final AggregatedCacheListener<K, V> aggregatedCacheListener =
203                    new AggregatedCacheListener<K, V>();
204    
205    }