UserMap.java

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import org.spongepowered.api.Sponge;
import org.spongepowered.api.entity.living.player.Player;
import org.spongepowered.api.entity.living.player.User;
import org.spongepowered.api.service.user.UserStorageService;

/**
 * A wrapper map for correctly storing user/player information using UUIDs instead of using User or Player directly.
 * You can do without using this class, but this is meant for lazy and new plugin developers.
 * @author Zephlon
 * @param <T>
 */
public class UserMap<T> implements Map<UUID, T> {

    private final Map<UUID, T> map;

    public UserMap() {
        this.map = new HashMap();
    }
    private UserMap(Map<UUID, T> map) {
        this.map = map;
    }

    public static <E> UserMap<E> wrap(Map<UUID, E> map) {
        return new UserMap(map);
    }

    //<editor-fold defaultstate="collapsed" desc=" Wrapper Implementation ">
    @Override
    public int size() {
        return map.size();
    }

    @Override
    public boolean isEmpty() {
        return map.isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
        return map.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
        return map.containsValue(value);
    }

    @Override
    public T get(Object key) {
        return map.get(key);
    }

    @Override
    public T put(UUID key, T value) {
        return map.put(key, value);
    }

    @Override
    public T remove(Object key) {
        return map.remove(key);
    }

    @Override
    public void putAll(Map<? extends UUID, ? extends T> m) {
        map.putAll(m);
    }

    @Override
    public void clear() {
        map.clear();
    }

    @Override
    public Set<UUID> keySet() {
        return map.keySet();
    }

    @Override
    public Collection<T> values() {
        return map.values();
    }

    @Override
    public Set<Entry<UUID, T>> entrySet() {
        return map.entrySet();
    }
    //</editor-fold>

    public boolean containsKey(UUID key) {
        return map.containsKey(key);
    }
    public boolean containsKey(User key) {
        return map.containsKey(key.getUniqueId());
    }

    public T get(UUID key) {
        return map.get(key);
    }
    public T get(User key) {
        return map.get(key.getUniqueId());
    }

    public T getOrDefault(UUID key, T defaultValue) {
        if (containsKey(key)) {
            return get(key);
        } else {
            return defaultValue;
        }
    }
    public T getOrDefault(User key, T defaultValue) {
        return getOrDefault(key.getUniqueId(), defaultValue);
    }

    public T put(User key, T value) {
        return map.put(key.getUniqueId(), value);
    }

    public T remove(UUID key) {
        return map.remove(key);
    }
    public T remove(User key) {
        return map.remove(key.getUniqueId());
    }

    public Set<User> userSet() {
        Optional<UserStorageService> userStorage = Sponge.getServiceManager().provide(UserStorageService.class);
        Set<User> users = new HashSet();

        for (UUID uuid : map.keySet()) {
            Optional<User> user = userStorage.get().get(uuid);

            if (user.isPresent()) {
                users.add(user.get());
            }
        }

        return users;
    }

    public Set<Player> playerSet() {
        Set<Player> players = new HashSet();

        for (UUID uuid : map.keySet()) {
            Optional<Player> player = Sponge.getServer().getPlayer(uuid);

            if (player.isPresent()) {
                players.add(player.get());
            }
        }

        return players;
    }
}