org.asynchttpclient.shaded.io.netty.util.ConstantPool Maven / Gradle / Ivy
/*
* Copyright 2013 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 org.asynchttpclient.shaded.io.netty.util;
import org.asynchttpclient.shaded.io.netty.util.internal.ObjectUtil;
import org.asynchttpclient.shaded.io.netty.util.internal.PlatformDependent;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
/**
* A pool of {@link Constant}s.
*
* @param the type of the constant
*/
public abstract class ConstantPool> {
private final ConcurrentMap constants = PlatformDependent.newConcurrentHashMap();
private final AtomicInteger nextId = new AtomicInteger(1);
/**
* Shortcut of {@link #valueOf(String) valueOf(firstNameComponent.getName() + "#" + secondNameComponent)}.
*/
public T valueOf(Class firstNameComponent, String secondNameComponent) {
return valueOf(
ObjectUtil.checkNotNull(firstNameComponent, "firstNameComponent").getName() +
'#' +
ObjectUtil.checkNotNull(secondNameComponent, "secondNameComponent"));
}
/**
* Returns the {@link Constant} which is assigned to the specified {@code name}.
* If there's no such {@link Constant}, a new one will be created and returned.
* Once created, the subsequent calls with the same {@code name} will always return the previously created one
* (i.e. singleton.)
*
* @param name the name of the {@link Constant}
*/
public T valueOf(String name) {
checkNotNullAndNotEmpty(name);
return getOrCreate(name);
}
/**
* Get existing constant by name or creates new one if not exists. Threadsafe
*
* @param name the name of the {@link Constant}
*/
private T getOrCreate(String name) {
T constant = constants.get(name);
if (constant == null) {
final T tempConstant = newConstant(nextId(), name);
constant = constants.putIfAbsent(name, tempConstant);
if (constant == null) {
return tempConstant;
}
}
return constant;
}
/**
* Returns {@code true} if a {@link AttributeKey} exists for the given {@code name}.
*/
public boolean exists(String name) {
checkNotNullAndNotEmpty(name);
return constants.containsKey(name);
}
/**
* Creates a new {@link Constant} for the given {@code name} or fail with an
* {@link IllegalArgumentException} if a {@link Constant} for the given {@code name} exists.
*/
public T newInstance(String name) {
checkNotNullAndNotEmpty(name);
return createOrThrow(name);
}
/**
* Creates constant by name or throws exception. Threadsafe
*
* @param name the name of the {@link Constant}
*/
private T createOrThrow(String name) {
T constant = constants.get(name);
if (constant == null) {
final T tempConstant = newConstant(nextId(), name);
constant = constants.putIfAbsent(name, tempConstant);
if (constant == null) {
return tempConstant;
}
}
throw new IllegalArgumentException(String.format("'%s' is already in use", name));
}
private static String checkNotNullAndNotEmpty(String name) {
ObjectUtil.checkNotNull(name, "name");
if (name.isEmpty()) {
throw new IllegalArgumentException("empty name");
}
return name;
}
protected abstract T newConstant(int id, String name);
@Deprecated
public final int nextId() {
return nextId.getAndIncrement();
}
}