org.nuiton.util.AliasMap Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of nuiton-utils Show documentation
Show all versions of nuiton-utils Show documentation
Library of usefull class to be used in any project.
package org.nuiton.util;
/*
* #%L
* Nuiton Utils
* %%
* Copyright (C) 2004 - 2013 CodeLutin
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Lesser Public License for more details.
*
* You should have received a copy of the GNU General Lesser Public
* License along with this program. If not, see
* .
* #L%
*/
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.map.MultiValueMap;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.UUID;
/**
* Une map base sur une HashMap qui permet pour une valeur d'ajouter d'autres
* cles. Cette nouvelle cle est un alias, un alias peut-etre utilise pour
* plusieurs valeurs. Si l'on demande la valeur associe a un Alias, cela
* retourne une liste contenant toutes les valeurs pour lequel cette Alias est
* utilise.
*
* Cela permet de stocker des objets avec une cle principale et unique, puis
* avec des alias.
*
* Et ainsi recherche les valeurs qui ont un ensemble d'alias via la methode
* {@link #getValueAlias(Object[]) } ou supprimer les valeurs qui
* ont un ensemble d'Alias en commun via la methode {@link #removeValue}
*
* Si la cle ne vous importe que peu, vous pouvez par exemple utiliser
* {@link UUID#randomUUID()} pour generer une cle unique.
*
* @author Benjamin Poussin - [email protected]
* @since 3.6.9
*/
public class AliasMap extends HashMap {
/** Logger. */
private static final Log log = LogFactory.getLog(AliasMap.class);
private static final long serialVersionUID = 1L;
/** key: alias, value: key */
protected MultiValueMap aliases;
/** key: key, value: alias */
protected MultiValueMap keys;
public AliasMap() {
aliases = MultiValueMap.multiValueMap(new HashMap(), HashSet.class);
keys = MultiValueMap.multiValueMap(new HashMap(), HashSet.class);
}
/**
* Ajoute une valeur dans la map avec un ensemble d'alias associe
*
* @param key identifiant unique pour cette valeur
* @param value la valeur
* @param alias1 le premier alias à saisir
* @param alias les alias de la valeur
* @return FIXME
*/
public V put(K key, V value, A alias1, A ... alias) {
V result = put(key, value);
putAlias(key, alias1, alias);
return result;
}
/**
* Ajoute des alias a une cle
* @param key FIXME
* @param alias1 FIXME
* @param alias FIXME
*/
protected void putAlias(K key, A alias1, A ... alias) {
aliases.put(alias1, key);
keys.put(key, alias1);
for (Object a : alias) {
aliases.put(a, key);
keys.put(key, a);
}
}
/**
* Retoure les cles en commun de tous les alias. Les cles retournees sont
* celle qui ont tous les alias.
*
* K1: a, b, c
* K2: b, c, d
* K3: c, d, e
*
* getKeyAlias(a, b, c) retourne [K1]
* getKeyAlias(b, c) retourne [K1, K2]
* getKeyAlias(c) retourne [K1, K2, K3]
* getKeyAlias(d) retourne [K2, K3]
* getKeyAlias(z) retourne []
*
*
*
* @param alias FIXME
* @return une liste vide si aucune valeur ne correspond au alias en argument
*/
public Collection getKeyAlias(A ... alias) {
Collection result = null;
for (Object a : alias) {
Collection tmp = aliases.getCollection(a);
if (tmp != null) {
if (result == null) {
result = new HashSet(tmp);
} else {
result.retainAll(tmp);
}
}
}
if (result == null) {
result = Collections.emptySet();
}
return result;
}
/**
* Retoure les valeurs en commun de tous les alias. Les valeurs retournees sont
* celle qui ont tous les alias.
*
* V1: a, b, c
* V2: b, c, d
* V3: c, d, e
*
* getKeyAlias(a, b, c) retourne [V1]
* getKeyAlias(b, c) retourne [V1, V2]
* getKeyAlias(c) retourne [V1, V2, V3]
* getKeyAlias(d) retourne [V2, V3]
* getKeyAlias(z) retourne []
*
*
*
* @param alias FIXME
* @return une liste vide si aucune valeur ne correspond au alias en argument
*/
public Collection getValueAlias(A ... alias) {
Collection keys = getKeyAlias(alias);
Collection result = new HashSet(keys.size());
for (Object k : keys) {
result.add(get(k));
}
return result;
}
/**
* Retourne la liste d'alias associee avec une cle
*
*
* K1: a, b, c
* K2: b, c, d
* K3: c, d, e
*
* getAlias(K1) retourne [a, b, c]
* getAlias(k3) retourne [c, d, e]
* getKeyAlias(k9) retourne []
*
*
* @param key FIXME
* @return FIXME
*/
public Collection getAlias(K key) {
Collection result = keys.getCollection(key);
if (result == null) {
result = Collections.emptySet();
}
return result;
}
/**
* Retire une cle ainsi que tous ses alias
*
*
* K1: a, b, c
* K2: b, c, d
* K3: c, d, e
*
* remove(K1) il reste K2: [b, c, d], K3: [c, d, e]
*
*
* @param key FIXME
* @return FIXME
*/
@Override
public V remove(Object key) {
V result = super.remove(key);
Collection alias = getAlias((K)key);
keys.remove(key);
if (alias != null) {
for (Object a : alias) {
aliases.removeMapping(a, key);
if (CollectionUtils.isEmpty(aliases.getCollection(a))) {
aliases.remove(a);
}
}
}
return result;
}
/**
* Supprime toutes les valeurs et leur cle associe aux alias
*
*
* K1: a, b, c
* K2: b, c, d
* K3: c, d, e
*
* removeValue(b, c) il reste K3: [c, d, e]
*
*
* @param alias FIXME
* @return la liste de valeur qui a ete supprime de la map
*/
public Collection removeValue(A ... alias) {
Collection keys = getKeyAlias(alias);
Collection result = new ArrayList(keys.size());
for (Object k : keys) {
result.add(remove(k));
}
return result;
}
/**
* Supprime des alias quelque soit leur cle
*
*
* K1: a, b, c
* K2: b, c, d
* K3: c, d, e
*
* removeAlias(a, b) alors K1: [c], k2: [c, d], k3: [c, d, e]
* removeAlias(c) alors K1: [a, b], k2: [b, d], k3: [d, e]
* getKeyAlias(z) alors rien ne change car cette alias n'existe pas
*
*
* @param alias FIXME
*/
public void removeAlias(A ... alias) {
for (Object a : alias) {
Collection ks = aliases.getCollection(a);
aliases.remove(a);
if (ks != null) {
for (Object k : ks) {
keys.removeMapping(k, a);
}
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy