Java Tristate类代码示例

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
public static CompletableFuture<Boolean> setPermission(SubjectData data, Set<Context> contexts, String permission)
{
    try
    {
        Object result = SUBJECT_DATA_SET_PERMISSION.invoke(data, contexts, permission, Tristate.TRUE);
        if (result instanceof CompletableFuture)
        {
            @SuppressWarnings("unchecked")
            CompletableFuture<Boolean> future = (CompletableFuture) result;
            return future;
        }
        else
        {
            return CompletableFuture.completedFuture((Boolean) result);
        }
    }
    catch (Throwable throwable)
    {
        throw new UnsupportedOperationException(throwable);
    }
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order = Order.LAST)
@IsCancelled(Tristate.UNDEFINED)
public void onClientAuthMonitor(ClientConnectionEvent.Auth e) {
    /* Listen to see if the event was cancelled after we initially handled the connection
       If the connection was cancelled here, we need to do something to clean up the data that was loaded. */

    // Check to see if this connection was denied at LOW.
    if (this.deniedAsyncLogin.remove(e.getProfile().getUniqueId())) {

        // This is a problem, as they were denied at low priority, but are now being allowed.
        if (e.isCancelled()) {
            this.plugin.getLog().severe("Player connection was re-allowed for " + e.getProfile().getUniqueId());
            e.setCancelled(true);
        }
    }
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order = Order.FIRST)
@IsCancelled(Tristate.UNDEFINED)
public void onClientLogin(ClientConnectionEvent.Login e) {
    /* Called when the player starts logging into the server.
       At this point, the users data should be present and loaded.
       Listening on LOW priority to allow plugins to further modify data here. (auth plugins, etc.) */

    final GameProfile player = e.getProfile();

    if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) {
        this.plugin.getLog().info("Processing login event for " + player.getUniqueId() + " - " + player.getName());
    }

    final User user = this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(player.getUniqueId()));

    /* User instance is null for whatever reason. Could be that it was unloaded between asyncpre and now. */
    if (user == null) {
        this.deniedLogin.add(player.getUniqueId());

        this.plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded. - denying login.");
        e.setCancelled(true);
        e.setMessageCancelled(false);
        //noinspection deprecation
        e.setMessage(TextSerializers.LEGACY_FORMATTING_CODE.deserialize(Message.LOADING_ERROR.asString(this.plugin.getLocaleManager())));
    }
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order=Order.FIRST)
@IsCancelled(Tristate.UNDEFINED)
public void onChangeBlock(ChangeBlockEvent.Place event) {
	Optional<Player> optPlayer = event.getCause().get(NamedCause.SOURCE, Player.class);
	if (!optPlayer.isPresent()) return;
	
	Player player = optPlayer.get();
	if (!this.players.contains(player.getUniqueId())) return;
	
	event.setCancelled(true);
	
	event.getTransactions().forEach(transaction -> {
		player.sendMessage(Text.of(TextColors.GRAY, TextStyles.BOLD, "============================================"));
		player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Block Type: ", TextColors.BLUE, TextStyles.RESET, transaction.getOriginal().getState().getId()));
		player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Block Owner: ", TextColors.BLUE, TextStyles.RESET, transaction.getOriginal().getCreator()));
		player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Block Notifier: ", TextColors.BLUE, TextStyles.RESET, transaction.getOriginal().getNotifier()));
	});
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order=Order.FIRST)
@IsCancelled(Tristate.UNDEFINED)
public void onInteractBlock(InteractBlockEvent.Primary event) {
	Optional<Player> optPlayer = event.getCause().get(NamedCause.SOURCE, Player.class);
	if (!optPlayer.isPresent()) return;
	
	Player player = optPlayer.get();
	if (!this.players.contains(player.getUniqueId())) return;
	
	event.setCancelled(true);
	
	player.sendMessage(Text.of(TextColors.GRAY, TextStyles.BOLD, "============================================"));
	player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Block Type: ", TextColors.BLUE, TextStyles.RESET, event.getTargetBlock().getState().getId()));
	player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Block Owner: ", TextColors.BLUE, TextStyles.RESET, event.getTargetBlock().getCreator()));
	player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Block Notifier: ", TextColors.BLUE, TextStyles.RESET, event.getTargetBlock().getNotifier()));
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order=Order.FIRST)
@IsCancelled(Tristate.UNDEFINED)
public void onInteractEntity(InteractEntityEvent.Primary event) {
	Optional<Player> optPlayer = event.getCause().get(NamedCause.SOURCE, Player.class);
	if (!optPlayer.isPresent()) return;
	
	Player player = optPlayer.get();
	if (!this.players.contains(player.getUniqueId())) return;
	
	event.setCancelled(true);
	
	player.sendMessage(Text.of(TextColors.GRAY, TextStyles.BOLD, "============================================"));
	player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Entity Type: ", TextColors.BLUE, TextStyles.RESET, event.getTargetEntity().getType().getId()));
	player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Entity Owner: ", TextColors.BLUE, TextStyles.RESET, event.getTargetEntity().getCreator()));
	player.sendMessage(Text.of(TextColors.DARK_GREEN, TextStyles.BOLD, "Entity Notifier: ", TextColors.BLUE, TextStyles.RESET, event.getTargetEntity().getNotifier()));
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
public EPUserSubject(final EverPermissions plugin, final String identifier, final EPSubjectCollection<?> collection) {
 	super(plugin, identifier, collection);

 	this.data = new EPUserData(this.plugin, this, false);
     this.transientData = new EPUserData(this.plugin, this, true);
     
     // Cache
this.cachePermissions = CacheBuilder.newBuilder()
	    .maximumSize(16)
	    .expireAfterAccess(10, TimeUnit.MINUTES)
	    .build(new CacheLoader<String, Tristate>() {
		@Override
		public Tristate load(String permission) throws Exception {
			return EPUserSubject.this.getPermissionValue(permission);
		}
	    });
this.cacheOptions = CacheBuilder.newBuilder()
	    .maximumSize(16)
	    .expireAfterAccess(10, TimeUnit.MINUTES)
	    .build(new CacheLoader<String, Optional<String>>() {
		@Override
		public Optional<String> load(String option) throws Exception {
			return EPUserSubject.this.getOption(option);
		}
	    });
 }
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
/**
 * Retourne la valeur de la permission
 * @param permission La permission
 * @return La valeur de la permission
 */
public Tristate getTristate(final String permission) {
    Iterable<String> parts = NODE_SPLITTER.split(permission.toLowerCase());
    EPNode currentNode = this;
    Tristate lastUndefinedVal = Tristate.UNDEFINED;
    for (String str : parts) {
        if (!currentNode.containsKey(str)) {
            break;
        }
        currentNode = currentNode.get(str);
        
        if (currentNode.getTristate() != Tristate.UNDEFINED) {
            lastUndefinedVal = currentNode.getTristate();
        }
    }
    return lastUndefinedVal;

}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
/**
 * Création d'un node à partir d'une map
 * @param values Permission : Valeur
 * @param defaultValue La valeur par défaut
 * @return Le node
 */
public static EPNode of(final Map<String, Boolean> values, final Tristate defaultValue) {
	EPNode newTree = new EPNode(defaultValue);
    for (Map.Entry<String, Boolean> value : values.entrySet()) {
        Iterable<String> parts = NODE_SPLITTER.split(value.getKey().toLowerCase());
        EPNode currentNode = newTree;
        for (String part : parts) {
            if (currentNode.containsKey(part)) {
                currentNode = currentNode.get(part);
            } else {
            	EPNode newNode = new EPNode();
                currentNode.put(part, newNode);
                currentNode = newNode;
            }
        }
        currentNode.setTristate(Tristate.fromBoolean(value.getValue()));
    }
    return newTree;
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
/**
 * Modifie une permission
 * @param node Le node
 * @param value La valeur
 * @return Le nouveau node
 */
public EPNode withValue(final String node, final Tristate value) {
    Iterable<String> parts = NODE_SPLITTER.split(node.toLowerCase());
    EPNode newRoot = this.copy();
    EPNode currentPtr = newRoot;

    for (String part : parts) {
    	EPNode oldChild = currentPtr.get(part);
    	EPNode newChild;
        if (oldChild == null) {
        	newChild = new EPNode();
        } else {
        	newChild = oldChild.copy();
        }
        currentPtr.put(part, newChild);
        currentPtr = newChild;
    }
    currentPtr.setTristate(value);
    return newRoot;
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Override
public CompletableFuture<Boolean> setPermission(final String typeWorld, final String permission, final Tristate value) {
	Preconditions.checkNotNull(typeWorld, "typeWorld");
	Preconditions.checkNotNull(permission, "permission");
	Preconditions.checkNotNull(value, "value");
	
	return CompletableFuture.supplyAsync(() -> {
		Boolean oldValue = this.getNodeTree(typeWorld).asMap().get(permission);
		boolean insert = oldValue == null;
		
		if (insert && value.equals(Tristate.UNDEFINED)) return false;
		if (!insert && !value.equals(Tristate.UNDEFINED) && oldValue.booleanValue() == value.asBoolean()) return false;
		
		if (!this.getSubject().getContainingCollection().getStorage().setPermission(this, typeWorld, permission, value, insert)) return false;
		
		this.setPermissionExecute(typeWorld, permission, value);
		this.onUpdate();
		return true;
	}, this.plugin.getThreadAsync());
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
public void setPermissionExecute(final String typeWorld, final String permission, final Tristate value) {
	this.write_lock.lock();
	try {
		EPNode oldTree = this.permissions.get(typeWorld);
		if (oldTree == null) {
			if (value != Tristate.UNDEFINED) {
				this.permissions.putIfAbsent(typeWorld, EPNode.of(ImmutableMap.of(permission, value.asBoolean())));
			}
		} else if (value == Tristate.UNDEFINED) {
			if (oldTree.getTristate(permission) != Tristate.UNDEFINED) {
				this.permissions.put(typeWorld, oldTree.withValue(permission, value));
			}
		} else if (!oldTree.asMap().containsKey(permission) || oldTree.asMap().get(permission) != value.asBoolean()) {
			this.permissions.put(typeWorld, oldTree.withValue(permission, value));
		} 
	} finally {
		this.write_lock.unlock();
	}
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener
@IsCancelled(Tristate.FALSE)
public void onMoveEntityEventTeleport(MoveEntityEvent.Teleport event, @Root Player player) {
    if (event.getFromTransform().getExtent().equals(event.getToTransform().getExtent())) {
        return;
    }

    World world = event.getToTransform().getExtent();
    Vector3d rotation = null;
    for (SpawnEntity spawnEntity : SpawnCache.instance.get()) {
        if (spawnEntity.getWorld().getIdentifier().equals(world.getUniqueId().toString())) {
            rotation = spawnEntity.getRotation();
        }
    }

    if (rotation != null) {
        Transform<World> to = new Transform<>(world.getSpawnLocation());
        event.setToTransform(to.setRotation(rotation));
    }
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order = Order.LATE)
@IsCancelled(Tristate.FALSE)
@Include(PlayerTeleportEvent.Pre.class)
public void onPlayerTeleportPreEvent(PlayerTeleportEvent event) {
    Player player = event.getTargetEntity();
    PlayerEntity playerEntity = PlayerCache.instance.get(player);

    for (BackEntity backEntity : playerEntity.getBacks()) {
        if (backEntity.getLocation().getWorld().getIdentifier().equals(event.getLocation().getExtent().getUniqueId().toString())) {
            playerEntity.getBacks().remove(backEntity);
        }
    }

    playerEntity.getBacks().add(new BackEntity(new LocationEntity(event.getLocation(), event.getRotation())));
    playerEntity = PlayerRepository.instance.save(playerEntity);
    PlayerCache.instance.set(player, playerEntity);
}
 

import org.spongepowered.api.util.Tristate; //导入依赖的package包/类
@Listener(order = Order.LATE)
@IsCancelled(Tristate.FALSE)
@Exclude(PlayerTeleportEvent.Pre.class)
public void onPlayerTeleportEvent(PlayerTeleportEvent event) {
    Optional<SleepingData> optional = event.getTargetEntity().get(SleepingData.class);
    if (optional.isPresent() && optional.get().asImmutable().sleeping().get()) {
        event.getTargetEntity().sendMessage(MessagesUtil.get(event.getTargetEntity(), "teleport.sleep"));
        return;
    }

    if (event.getRotation() == null) {
        event.getTargetEntity().setLocationSafely(event.getLocation());
    } else {
        event.getTargetEntity().setLocationAndRotationSafely(event.getLocation(), event.getRotation());
    }
}