/*
* Copyright 2015 The Netty Project
*
* The Netty Project 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 io.netty.channel.pool;
import io.netty.util.internal.
PlatformDependent;
import io.netty.util.internal.
ReadOnlyIterator;
import java.io.
Closeable;
import java.util.
Iterator;
import java.util.
Map.
Entry;
import java.util.concurrent.
ConcurrentMap;
import static io.netty.util.internal.
ObjectUtil.checkNotNull;
/**
* A skeletal {@link ChannelPoolMap} implementation. To find the right {@link ChannelPool}
* the {@link Object#hashCode()} and {@link Object#equals(Object)} is used.
*/
public abstract class
AbstractChannelPoolMap<K, P extends
ChannelPool>
implements
ChannelPoolMap<K, P>,
Iterable<
Entry<K, P>>,
Closeable {
private final
ConcurrentMap<K, P>
map =
PlatformDependent.
newConcurrentHashMap();
@
Override
public final P
get(K
key) {
P
pool =
map.
get(
checkNotNull(
key, "key"));
if (
pool == null) {
pool =
newPool(
key);
P
old =
map.
putIfAbsent(
key,
pool);
if (
old != null) {
// We need to destroy the newly created pool as we not use it.
pool.
close();
pool =
old;
}
}
return
pool;
}
/**
* Remove the {@link ChannelPool} from this {@link AbstractChannelPoolMap}. Returns {@code true} if removed,
* {@code false} otherwise.
*
* Please note that {@code null} keys are not allowed.
*/
public final boolean
remove(K
key) {
P
pool =
map.
remove(
checkNotNull(
key, "key"));
if (
pool != null) {
pool.
close();
return true;
}
return false;
}
@
Override
public final
Iterator<
Entry<K, P>>
iterator() {
return new
ReadOnlyIterator<
Entry<K, P>>(
map.
entrySet().
iterator());
}
/**
* Returns the number of {@link ChannelPool}s currently in this {@link AbstractChannelPoolMap}.
*/
public final int
size() {
return
map.
size();
}
/**
* Returns {@code true} if the {@link AbstractChannelPoolMap} is empty, otherwise {@code false}.
*/
public final boolean
isEmpty() {
return
map.
isEmpty();
}
@
Override
public final boolean
contains(K
key) {
return
map.
containsKey(
checkNotNull(
key, "key"));
}
/**
* Called once a new {@link ChannelPool} needs to be created as non exists yet for the {@code key}.
*/
protected abstract P
newPool(K
key);
@
Override
public final void
close() {
for (K
key:
map.
keySet()) {
remove(
key);
}
}
}