com.tvd12.gamebox.manager.SynchronizedPlayerManager Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of game-box Show documentation
The newest version!
package com.tvd12.gamebox.manager;

import com.tvd12.gamebox.entity.Player;

import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class SynchronizedPlayerManager
    extends AbstractPlayerManager
 {

    public SynchronizedPlayerManager() {
        this(999999999);
    }

    public SynchronizedPlayerManager(int maxPlayer) {
        super(maxPlayer);
    }

    protected SynchronizedPlayerManager(Builder builder) {
        super(builder);
    }

    @SuppressWarnings("rawtypes")
    public static Builder builder() {
        return new Builder<>();
    }

    @Override
    public P getPlayer(String username) {
        synchronized (this) {
            return super.getPlayer(username);
        }
    }

    @Override
    public P getPlayer(String username, Supplier
 playerSupplier) {
        synchronized (this) {
            return super.getPlayer(username, playerSupplier);
        }
    }

    @Override
    public P getFirstPlayer() {
        synchronized (this) {
            return super.getFirstPlayer();
        }
    }

    @Override
    public List
 getPlayerList() {
        synchronized (this) {
            return super.getPlayerList();
        }
    }

    @Override
    public List
 getPlayerList(Predicate
 predicate) {
        synchronized (this) {
            return super.getPlayerList(predicate);
        }
    }

    @Override
    public void getPlayerList(List
 buffer) {
        synchronized (this) {
            super.getPlayerList(buffer);
        }
    }

    @Override
    public List getPlayerNames() {
        synchronized (this) {
            return super.getPlayerNames();
        }
    }

    @Override
    public boolean containsPlayer(String username) {
        synchronized (this) {
            return super.containsPlayer(username);
        }
    }

    @Override
    public void addPlayer(P player, boolean failIfAdded) {
        synchronized (this) {
            super.addPlayer(player, failIfAdded);
        }
    }

    @Override
    public void addPlayers(Collection
 players, boolean failIfAdded) {
        synchronized (this) {
            super.addPlayers(players, failIfAdded);
        }
    }

    @Override
    public P removePlayer(P player) {
        synchronized (this) {
            return super.removePlayer(player);
        }
    }

    @Override
    public void removePlayers(Collection
 players) {
        synchronized (this) {
            super.removePlayers(players);
        }
    }

    @Override
    public int getPlayerCount() {
        synchronized (this) {
            return super.getPlayerCount();
        }
    }

    @Override
    public boolean available() {
        synchronized (this) {
            return super.available();
        }
    }

    @Override
    public int countPlayers(Predicate
 tester) {
        synchronized (this) {
            return super.countPlayers(tester);
        }
    }

    @Override
    public void forEach(Consumer
 consumer) {
        synchronized (this) {
            super.forEach(consumer);
        }
    }

    @Override
    public List
 filterPlayers(Predicate tester) {
        synchronized (this) {
            return super.filterPlayers(tester);
        }
    }

    @Override
    public boolean isEmpty() {
        synchronized (this) {
            return super.isEmpty();
        }
    }

    @Override
    public void clear() {
        synchronized (this) {
            super.clear();
        }
    }

    public static class Builder>
        extends AbstractPlayerManager.Builder {

        @Override
        protected PlayerManager newProduct() {
            return new SynchronizedPlayerManager<>(this);
        }
    }
}