file_name
stringlengths
6
86
file_path
stringlengths
45
249
content
stringlengths
47
6.26M
file_size
int64
47
6.26M
language
stringclasses
1 value
extension
stringclasses
1 value
repo_name
stringclasses
767 values
repo_stars
int64
8
14.4k
repo_forks
int64
0
1.17k
repo_open_issues
int64
0
788
repo_created_at
stringclasses
767 values
repo_pushed_at
stringclasses
767 values
PreloadChunkListener.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/EventManagement/PreloadChunkListener.java
package com.github.catageek.ByteCart.EventManagement; import org.bukkit.Location; import org.bukkit.World; import org.bukkit.entity.Entity; import org.bukkit.entity.Minecart; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.vehicle.VehicleMoveEvent; import org.bukkit.event.world.ChunkUnloadEvent; import org.bukkit.util.Vector; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * Listener to load chunks around moving carts */ public final class PreloadChunkListener implements Listener { private final Vector NullVector = new Vector(0,0,0); @EventHandler(ignoreCancelled = true) public void onVehicleMove(VehicleMoveEvent event) { Location loc = event.getTo(); int to_x = loc.getBlockX() >> 4; int to_z = loc.getBlockZ() >> 4; if(event.getVehicle() instanceof Minecart) // we care only of minecart { // preload chunks MathUtil.loadChunkAround(loc.getWorld(), to_x, to_z, 2); } } /** * We cancel this event if a cart is moving in the chunk or around * * @param event */ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) @SuppressWarnings("ucd") public void onChunkUnload(ChunkUnloadEvent event) { int n, j, i = event.getChunk().getX()-2, k = i+4, l = event.getChunk().getZ()+2; World world = event.getWorld(); Entity[] entities; for (; i<=k; ++i) { for (j=l-4; j<=l ; ++j) { if (world.isChunkLoaded(i, j)) { entities = world.getChunkAt(i, j).getEntities(); for (n = entities.length -1; n >=0; --n) { if (entities[n] instanceof Minecart && !((Minecart)entities[n]).getVelocity().equals(NullVector)) { event.setCancelled(true); return; } } } } } } }
1,793
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ConstantSpeedListener.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/EventManagement/ConstantSpeedListener.java
package com.github.catageek.ByteCart.EventManagement; import java.util.HashMap; import java.util.List; import java.util.Map; import org.bukkit.Location; import org.bukkit.block.data.BlockData; import org.bukkit.block.data.Rail; import org.bukkit.entity.Entity; import org.bukkit.entity.Minecart; import org.bukkit.entity.Vehicle; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.vehicle.VehicleBlockCollisionEvent; import org.bukkit.event.vehicle.VehicleDestroyEvent; import org.bukkit.event.vehicle.VehicleEntityCollisionEvent; import org.bukkit.event.vehicle.VehicleMoveEvent; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * Listener to maintain cart speed */ public final class ConstantSpeedListener implements Listener { // We keep the speed of each cart in this map private final Map<Integer, Double> speedmap = new HashMap<Integer, Double>(); // empty Location private Location location = new Location(null, 0, 0, 0); @EventHandler(ignoreCancelled = true) @SuppressWarnings("ucd") public void onVehicleMove(VehicleMoveEvent event) { final Vehicle v = event.getVehicle(); if (! (v instanceof Minecart)) return; final Minecart m = (Minecart) v; double speed = MathUtil.getSpeed(m); int id = m.getEntityId(); final BlockData data = m.getLocation(location).getBlock().getState().getBlockData(); if (speed != 0 && (data instanceof Rail)) { Double storedspeed; if (! speedmap.containsKey(id)) speedmap.put(id, speed); else if ((storedspeed = speedmap.get(id)) > speed && storedspeed <= m.getMaxSpeed()) MathUtil.setSpeed(m, storedspeed); else speedmap.put(id, speed); } else speedmap.remove(id); } @EventHandler (ignoreCancelled = false, priority = EventPriority.MONITOR) @SuppressWarnings("ucd") public void onVehicleDestroy(VehicleDestroyEvent event) { speedmap.remove(event.getVehicle().getEntityId()); } @EventHandler (ignoreCancelled = false, priority = EventPriority.MONITOR) @SuppressWarnings("ucd") public void onVehicleEntityCollision(VehicleEntityCollisionEvent event) { final List<Entity> passengers = event.getVehicle().getPassengers(); for(Entity passenger : passengers) { if(passenger.getEntityId() == event.getEntity().getEntityId()) { return; } } speedmap.remove(event.getVehicle().getEntityId()); } @EventHandler (ignoreCancelled = false, priority = EventPriority.MONITOR) @SuppressWarnings("ucd") public void onVehicleBlockCollision(VehicleBlockCollisionEvent event) { speedmap.remove(event.getVehicle().getEntityId()); } }
2,664
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ByteCartInventoryListener.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/EventManagement/ByteCartInventoryListener.java
package com.github.catageek.ByteCart.EventManagement; import org.bukkit.entity.Entity; import org.bukkit.entity.Player; import org.bukkit.entity.minecart.StorageMinecart; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerInteractEntityEvent; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.InventoryHolder; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.ModifiableRunnable; import com.github.catageek.ByteCartAPI.Event.UpdaterCreateEvent; /** * Class implementing a listener and waiting for a player to right-click an inventory holder * and running a Runnable */ public class ByteCartInventoryListener implements Listener { private final Player Player; // the Runnable to update private final ModifiableRunnable<Inventory> Execute; // flag set when we deal with an updater command private final boolean isUpdater; public ByteCartInventoryListener(ByteCart plugin, Player player, ModifiableRunnable<Inventory> execute, boolean isupdater) { this.Player = player; this.Execute = execute; this.isUpdater = isupdater; // self registering as Listener plugin.getServer().getPluginManager().registerEvents(this, plugin); } @EventHandler (ignoreCancelled = false) public void onPlayerInteractEntity(PlayerInteractEntityEvent event) { Entity entity; Inventory inv; if (event.getPlayer().equals(Player) && ((entity = event.getRightClicked()) instanceof InventoryHolder)) { // we set the member and run the Runnable this.Execute.SetParam(inv = ((InventoryHolder) entity).getInventory()); this.Execute.run(); // we cancel the right-click event.setCancelled(true); if (isUpdater) { // we launch an UpdaterCreateEvent StorageMinecart v = (StorageMinecart) inv.getHolder(); UpdaterCreateEvent e = new UpdaterCreateEvent(v.getEntityId(), v.getLocation()); ByteCart.myPlugin.getServer().getPluginManager().callEvent(e); } } // Self unregistering PlayerInteractEntityEvent.getHandlerList().unregister(this); } }
2,090
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ByteCartListener.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/EventManagement/ByteCartListener.java
package com.github.catageek.ByteCart.EventManagement; import java.util.Iterator; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; import org.bukkit.block.Sign; import org.bukkit.entity.Entity; import org.bukkit.entity.Minecart; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; import org.bukkit.event.Listener; import org.bukkit.event.block.Action; import org.bukkit.event.block.BlockBreakEvent; import org.bukkit.event.block.BlockPhysicsEvent; import org.bukkit.event.block.SignChangeEvent; import org.bukkit.event.entity.EntityChangeBlockEvent; import org.bukkit.event.entity.EntityExplodeEvent; import org.bukkit.event.player.PlayerInteractEvent; import org.bukkit.event.vehicle.VehicleCreateEvent; import org.bukkit.event.vehicle.VehicleMoveEvent; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.HAL.AbstractIC; import com.github.catageek.ByteCart.Signs.Clickable; import com.github.catageek.ByteCart.Signs.ClickedSignFactory; import com.github.catageek.ByteCart.Signs.Powerable; import com.github.catageek.ByteCart.Signs.PoweredSignFactory; import com.github.catageek.ByteCart.Signs.Triggable; import com.github.catageek.ByteCart.Signs.TriggeredSignFactory; import com.github.catageek.ByteCartAPI.Event.SignCreateEvent; import com.github.catageek.ByteCartAPI.Event.SignRemoveEvent; import com.github.catageek.ByteCartAPI.HAL.IC; /** * The main listener */ public class ByteCartListener implements Listener { private PoweredSignFactory MyPoweredICFactory; public ByteCartListener() { this.MyPoweredICFactory = new PoweredSignFactory(); } /** * Detect if a sign is under the cart moving * * @param event */ @EventHandler(ignoreCancelled = true) @SuppressWarnings("ucd") public void onVehicleMove(VehicleMoveEvent event) { Location loc = event.getFrom(); Integer from_x = loc.getBlockX(); Integer from_z = loc.getBlockZ(); loc = event.getTo(); int to_x = loc.getBlockX(); int to_z = loc.getBlockZ(); // Check if the vehicle crosses a cube boundary if(from_x == to_x && from_z == to_z) return; // no boundary crossed, resumed if(event.getVehicle() instanceof Minecart) // we care only of minecart { Minecart vehicle = (Minecart) event.getVehicle(); // we instantiate a member of the BCXXXX class // XXXX is read from the sign Triggable myIC; myIC = TriggeredSignFactory.getTriggeredIC(event.getTo().getBlock().getRelative(BlockFace.DOWN, 2),vehicle); if (myIC != null) { if(ByteCart.debug) ByteCart.log.info("ByteCart: " + myIC.getName() + ".trigger()"); myIC.trigger(); } } } /** * Detect a sign under the cart created * * @param event */ @EventHandler(ignoreCancelled = true) @SuppressWarnings("ucd") public void onVehicleCreate(VehicleCreateEvent event) { if(event.getVehicle() instanceof Minecart) // we care only of minecart { Minecart vehicle = (Minecart) event.getVehicle(); // we instantiate a member of the BCXXXX class // XXXX is read from the sign Triggable myIC; myIC = TriggeredSignFactory.getTriggeredIC(vehicle.getLocation().getBlock().getRelative(BlockFace.DOWN, 2),vehicle); if (myIC != null) { myIC.trigger(); } } } /** * Detect if we create a sign * * @param event */ @EventHandler(ignoreCancelled = true) @SuppressWarnings("ucd") public void onSignChange(SignChangeEvent event) { if (! AbstractIC.checkEligibility(event.getLine(1))) return; AbstractIC.removeFromCache(event.getBlock()); IC myIC = TriggeredSignFactory.getTriggeredIC(event.getBlock(), event.getLine(1), null); if (myIC == null) { myIC = ClickedSignFactory.getClickedIC(event.getBlock(), event.getLine(1), event.getPlayer()); } if (myIC == null) { myIC = PoweredSignFactory.getPoweredIC(event.getBlock(), event.getLine(1)); } if (myIC != null) { Player player = event.getPlayer(); if (! player.hasPermission(myIC.getBuildPermission())) { player.sendMessage(ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED +"You are not authorized to place " + myIC.getFriendlyName() + " block."); player.sendMessage(ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED +"You must have " + myIC.getBuildPermission()); event.setLine(1, ""); } else { player.sendMessage(ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED + myIC.getFriendlyName() + " block created."); int tax = myIC.getBuildtax(); if (tax > 0) player.sendMessage(ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED + "Tarif : " +myIC.getBuildtax() + " eur0x."); if (event.getLine(2).compareTo("") == 0) event.setLine(2, myIC.getFriendlyName()); Bukkit.getPluginManager().callEvent(new SignCreateEvent(myIC, player, event.getLines())); } } } /** * Check if a sign was broken * * @param event */ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR) @SuppressWarnings("ucd") public void onBlockBreak(BlockBreakEvent event) { removeSignIfNeeded(event.getBlock(), event.getPlayer()); } @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR) @SuppressWarnings("ucd") public void onEntityChangeBlock(EntityChangeBlockEvent event) { removeSignIfNeeded(event.getBlock(), event.getEntity()); } /** * Check if a sign was destroyed in the explosion * * @param event */ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR) @SuppressWarnings("ucd") public void onEntityExplode(EntityExplodeEvent event) { Entity entity = event.getEntity(); Iterator<Block> it = event.blockList().iterator(); while (it.hasNext()) removeSignIfNeeded(it.next(), entity); } /** * Check if a block is powered above a sign. * * @param event */ @EventHandler(ignoreCancelled = true) @SuppressWarnings("ucd") public void onBlockPhysics(BlockPhysicsEvent event) { if (event.getChangedType() != Material.SIGN || ! event.getBlock().isBlockIndirectlyPowered()) { return; } final Powerable myIC = this.MyPoweredICFactory.getIC(event.getBlock()); if (myIC != null) { myIC.power(); } } /* @EventHandler(ignoreCancelled = true) public void onBlockRedstone(BlockRedstoneEvent event) { Block block = event.getBlock().getRelative(BlockFace.DOWN); List<Block> blocks = new ArrayList<Block>(4); blocks.add(block.getRelative(BlockFace.NORTH)); blocks.add(block.getRelative(BlockFace.EAST)); blocks.add(block.getRelative(BlockFace.SOUTH)); blocks.add(block.getRelative(BlockFace.WEST)); for (Block b : blocks) { if (! AbstractIC.checkEligibility(b)) continue; Powerable myIC = this.MyPoweredICFactory.getIC(b); if (myIC != null) { try { if(ByteCart.debug) ByteCart.log.info("ByteCart: power()"); myIC.power(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } return; } } */ /** * Detect a sign that a player right-clicks * * @param event */ @EventHandler(ignoreCancelled = true) @SuppressWarnings("ucd") public void onPlayerInteract(PlayerInteractEvent event) { if (event.getAction().compareTo(Action.RIGHT_CLICK_BLOCK) != 0) return; Clickable myIC = ClickedSignFactory.getClickedIC(event.getClickedBlock(), event.getPlayer()); if (myIC == null) myIC = ClickedSignFactory.getBackwardClickedIC(event.getClickedBlock(), event.getPlayer()); if (myIC != null) { if(ByteCart.debug) ByteCart.log.info("ByteCart: " + myIC.getName() + ".click()"); myIC.click(); event.setCancelled(true); } } /** * Remove sign from cache and launch event * * @param block the sign * @param entity the entity at origin of the event */ private static void removeSignIfNeeded(Block block, Entity entity) { if (! (block.getState() instanceof Sign)) return; IC myIC; myIC = TriggeredSignFactory.getTriggeredIC(block, null); if (myIC == null) myIC = ClickedSignFactory.getClickedIC(block, null); if (myIC != null) { Bukkit.getPluginManager().callEvent(new SignRemoveEvent(myIC, entity)); AbstractIC.removeFromCache(block); } } }
8,402
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/ThreadManagement/package-info.java
/** * */ /** * Utilities for threads */ package com.github.catageek.ByteCart.ThreadManagement;
99
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Expirable.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/ThreadManagement/Expirable.java
package com.github.catageek.ByteCart.ThreadManagement; import java.util.Collections; import java.util.HashMap; import java.util.Map; import org.bukkit.scheduler.BukkitTask; /* * HashMap that keeps entries during "duration" ticks */ public abstract class Expirable<K> { private Map<K, BukkitTask> ThreadMap = Collections.synchronizedMap(new HashMap<K,BukkitTask>()); private final long Duration; private final String name; private final boolean IsSync; abstract public void expire(Object...objects); /** * @param duration the timeout value * @param isSync true if the element must be removed synchronously in the main thread * @param name a name for the set */ public Expirable(long duration, boolean isSync, String name) { super(); this.Duration = duration; this.name = name; this.IsSync = isSync; } public void reset(K key, Object...objects) { if (Duration != 0) (new BCBukkitRunnable<K>(this, key)).renewTaskLater(objects); } public void reset(long duration, K key, Object...objects) { if (duration != 0) (new BCBukkitRunnable<K>(this, key)).renewTaskLater(duration, objects); } public final void cancel(K key) { if (Duration != 0) (new BCBukkitRunnable<K>(this, key)).cancel(); } protected final Map<K, BukkitTask> getThreadMap() { return ThreadMap; } public final long getDuration() { return Duration; } public final boolean isSync() { return IsSync; } public final String getName() { return name; } }
1,485
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BCBukkitRunnable.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/ThreadManagement/BCBukkitRunnable.java
package com.github.catageek.ByteCart.ThreadManagement; import java.util.Map; import org.bukkit.scheduler.BukkitRunnable; import org.bukkit.scheduler.BukkitTask; import com.github.catageek.ByteCart.ByteCart; /** * A class that schedule tasks to manage the automatic removal of elements * * @param <K> key used in the map or set */ final class BCBukkitRunnable<K> { private final Expirable<K> Expirable; private final K Key; /** * @param expirable the Collection implementing Expirable * @param key the key of the collection to which this task will be referenced */ BCBukkitRunnable(Expirable<K> expirable, K key) { this.Expirable = expirable; this.Key = key; } /** * Schedule or reschedule an Expirable task with a specific timeout delay * * @param duration the timeout to set * @param objects arguments to pass to the abstract Expirable.expire() method * @return the BukkitTask scheduled */ BukkitTask renewTaskLater(long duration, Object...objects) { BukkitTask task; Map<K,BukkitTask> map = Expirable.getThreadMap(); synchronized(map) { if(! Expirable.getThreadMap().containsKey(Key)) { task = (Expirable.isSync() ? this.runTaskLater(objects) : this.runTaskLaterAsynchronously(objects)); } else { BukkitTask old = Expirable.getThreadMap().get(Key); BukkitRunnable runnable = new Expire(Expirable, Key, objects); if (old.isSync()) task = runnable.runTaskLater(ByteCart.myPlugin, duration); else task = runnable.runTaskLaterAsynchronously(ByteCart.myPlugin, duration); old.cancel(); } Expirable.getThreadMap().put(Key, task); } return task; } /** * Schedule or reschedule an Expirable task with the default timeout delay * * @param objects arguments to pass to the abstract Expirable.expire() method * @return the BukkitTask scheduled */ BukkitTask renewTaskLater(Object...objects) { return renewTaskLater(Expirable.getDuration(), objects); } /** * Cancel the task * */ void cancel() { if(Expirable.getThreadMap().containsKey(Key)) Expirable.getThreadMap().remove(Key); } /** * Schedule an Expirable task synchronously * * @param objects the arguments to pass to Expirable.expire() method * @return the task scheduled */ private BukkitTask runTaskLater(Object...objects) { BukkitRunnable runnable = new Expire(Expirable, Key, objects); org.bukkit.scheduler.BukkitTask task = runnable.runTaskLater(ByteCart.myPlugin, Expirable.getDuration()); return task; } /** * Schedule an Expirable task asynchronously * * @param objects the arguments to pass to Expirable.expire() method * @return the task scheduled */ private BukkitTask runTaskLaterAsynchronously(Object...objects) { BukkitRunnable runnable = new Expire(Expirable, Key, objects); org.bukkit.scheduler.BukkitTask task = runnable.runTaskLaterAsynchronously(ByteCart.myPlugin, Expirable.getDuration()); return task; } /** * A runnable that will execute the expire() method and clean internal map */ private final class Expire extends BukkitRunnable { private final Expirable<K> expirable; private final K key; private final Object[] params; public Expire(Expirable<K> expirable, K key, Object...objects) { this.key = key; this.expirable = expirable; this.params = objects; } /* (non-Javadoc) * @see java.lang.Runnable#run() */ @Override public void run() { Map<K,BukkitTask> map = this.expirable.getThreadMap(); map.remove(key); this.expirable.expire(params); } } }
3,559
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandBCDMapSync.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandBCDMapSync.java
package com.github.catageek.ByteCart.Commands; import java.util.Collections; import java.util.List; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import com.github.catageek.ByteCart.plugins.BCDynmapPlugin; public class CommandBCDMapSync implements CommandExecutor, TabCompleter { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { BCDynmapPlugin.removeObsoleteMarkers(); return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { return Collections.emptyList(); } }
721
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandBCTicket.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandBCTicket.java
package com.github.catageek.ByteCart.Commands; import java.util.List; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import com.github.catageek.ByteCart.Signs.BC7010; import com.github.catageek.ByteCartAPI.ByteCartPlugin; public class CommandBCTicket extends AbstractTicketCommand implements CommandExecutor, TabCompleter { public CommandBCTicket(ByteCartPlugin plugin) { super(plugin); } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { if (args.length < 2) return false; @SuppressWarnings("deprecation") Player player = Bukkit.getServer().getPlayer(args[0]); if(player == null) { sender.sendMessage(ChatColor.DARK_GREEN + "[Bytecart] " + ChatColor.RED + "Can't find player " + args[0] + "."); return false; } return parse(sender, player, 1, args); } else { return parse(sender, (Player) sender, 0, args); } } @Override protected boolean run(CommandSender sender, Player player, String addressString, boolean isTrain) { (new BC7010(player.getLocation().getBlock(), player)).setAddress(addressString, null, isTrain); player.sendMessage(ChatColor.DARK_GREEN + "[Bytecart] " + ChatColor.YELLOW + "Ticket created successfully."); return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { if (!(sender instanceof Player)) { if (args.length <= 1) { // List players return null; } else { return tabComplete(1, args); } } else { return tabComplete(0, args); } } }
1,819
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/package-info.java
/** * Contains command executors for various commands. */ package com.github.catageek.ByteCart.Commands;
106
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandMeGo.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandMeGo.java
package com.github.catageek.ByteCart.Commands; import java.util.List; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import com.github.catageek.ByteCart.Signs.BC7010; import com.github.catageek.ByteCartAPI.ByteCartPlugin; public class CommandMeGo extends AbstractTicketCommand implements CommandExecutor, TabCompleter { public CommandMeGo(ByteCartPlugin plugin) { super(plugin); } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { sender.sendMessage("This command can only be run by a player."); return true; } else { return parse(sender, (Player) sender, 0, args); } } @Override protected boolean run(CommandSender sender, Player player, String addressString, boolean isTrain) { (new BC7010(player.getLocation().getBlock(), player)).setAddress(addressString, null, isTrain); return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { return tabComplete(0, args); } }
1,215
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandBCReload.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandBCReload.java
package com.github.catageek.ByteCart.Commands; import java.util.Collections; import java.util.List; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.Util.LogUtil; public class CommandBCReload implements CommandExecutor, TabCompleter { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { ByteCart.myPlugin.reloadConfig(); ByteCart.myPlugin.loadConfig(); String s = "Configuration file reloaded."; if (!(sender instanceof Player)) { sender.sendMessage(s); } else { Player player = (Player) sender; LogUtil.sendError(player, s); } return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { return Collections.emptyList(); } }
1,011
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandSendTo.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandSendTo.java
package com.github.catageek.ByteCart.Commands; import java.util.List; import org.bukkit.ChatColor; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.ModifiableRunnable; import com.github.catageek.ByteCart.AddressLayer.AddressFactory; import com.github.catageek.ByteCart.AddressLayer.AddressRouted; import com.github.catageek.ByteCart.EventManagement.ByteCartInventoryListener; import com.github.catageek.ByteCart.Signs.BC7011; import com.github.catageek.ByteCart.Util.LogUtil; import com.github.catageek.ByteCartAPI.ByteCartPlugin; public class CommandSendTo extends AbstractTicketCommand implements CommandExecutor, TabCompleter { public CommandSendTo(ByteCartPlugin plugin) { super(plugin); } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { sender.sendMessage("This command can only be run by a player."); return true; } else { return parse(sender, (Player) sender, 0, args); } } private static final class Execute implements ModifiableRunnable<Inventory> { private final Player player; private final String address; private Inventory inventory; private boolean istrain; private Execute(Player player, String host_or_address, boolean isTrain) { this.player = player; this.address = host_or_address; this.istrain = isTrain; } @Override public void run() { if ((new BC7011(player.getLocation().getBlock(), ((org.bukkit.entity.Vehicle) inventory.getHolder()))).setAddress(address, null, this.istrain)) { LogUtil.sendSuccess(player, ByteCart.myPlugin.getConfig().getString("Info.SetAddress") + " " + address); LogUtil.sendSuccess(player, ByteCart.myPlugin.getConfig().getString("Info.GetTTL") + AddressFactory.<AddressRouted>getAddress(inventory).getTTL()); } else LogUtil.sendError(player, ByteCart.myPlugin.getConfig().getString("Error.SetAddress") ); } /** * @param inventory * @param inventory the inventory to set */ @Override public void SetParam(Inventory inventory) { this.inventory = inventory; } } @Override protected boolean run(CommandSender sender, Player player, String addressString, boolean isTrain) { player.sendMessage(ChatColor.DARK_GREEN + "[Bytecart] " + ChatColor.YELLOW + ByteCart.myPlugin.getConfig().getString("Info.RightClickCart") ); new ByteCartInventoryListener(ByteCart.myPlugin, player, new Execute(player, addressString, isTrain), false); return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { return tabComplete(0, args); } }
2,910
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandBCUpdater.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandBCUpdater.java
package com.github.catageek.ByteCart.Commands; import java.util.Collections; import java.util.List; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import org.bukkit.entity.minecart.StorageMinecart; import org.bukkit.event.Listener; import org.bukkit.inventory.Inventory; import org.bukkit.util.StringUtil; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.ModifiableRunnable; import com.github.catageek.ByteCart.EventManagement.ByteCartInventoryListener; import com.github.catageek.ByteCart.EventManagement.ByteCartUpdaterMoveListener; import com.github.catageek.ByteCart.Updaters.UpdaterFactory; import com.github.catageek.ByteCart.Util.LogUtil; import com.github.catageek.ByteCart.Wanderer.BCWandererManager; import com.github.catageek.ByteCartAPI.Wanderer.Wanderer; import com.google.common.collect.Lists; public class CommandBCUpdater implements CommandExecutor, TabCompleter { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (args.length == 1 && args[0].equalsIgnoreCase("remove")) { BCWandererManager wm = ByteCart.myPlugin.getWandererManager(); wm.getFactory("Updater").removeAllWanderers(); wm.unregister("Updater"); return true; } if (!(sender instanceof Player)) { sender.sendMessage("This command can only be run by a player."); } else { Player player = (Player) sender; int region = 0; if(args.length == 0 || args.length > 4 || !Wanderer.Level.isMember(args[0].toLowerCase())) return false; if (args.length == 1 && ! args[0].equalsIgnoreCase("backbone") && ! args[0].equalsIgnoreCase("reset_backbone")) return false; boolean full_reset = false; boolean isnew = false; if (! ByteCart.myPlugin.getWandererManager().isRegistered("Updater")) ByteCart.myPlugin.getWandererManager().register(new UpdaterFactory(), "Updater"); if (args.length >= 2){ if (! args[0].equalsIgnoreCase("region") && ! args[0].equalsIgnoreCase("local") && ! args[0].equalsIgnoreCase("reset_region") && ! args[0].equalsIgnoreCase("reset_local")) return false; region = Integer.parseInt(args[1]); if (region < 1 || region > 2047) return false; if (args.length == 3) { if (args[0].startsWith("reset")) { if (args[2].equalsIgnoreCase("full")) full_reset = true; else return false; } else if (args[2].equalsIgnoreCase("new")) isnew = true; else return false; } } final class Execute implements ModifiableRunnable<Inventory> { private final Player player; private final Wanderer.Level level; private final int region; private Inventory inventory; private boolean isfullreset; private boolean isnew; private Execute(Player player, Wanderer.Level level, int region, boolean isfullreset, boolean isnew) { this.player = player; this.level = level; this.region = region; this.isfullreset = isfullreset; this.isnew = isnew; } @Override public void run() { int id = ((StorageMinecart) inventory.getHolder()).getEntityId(); // register updater factory final BCWandererManager wm = ByteCart.myPlugin.getWandererManager(); if (! wm.isRegistered("Updater")) wm.register(new UpdaterFactory(), "Updater"); wm.getFactory("Updater").createWanderer(id, inventory, region, level, player, isfullreset, isnew); if (! ByteCartUpdaterMoveListener.isExist()) { Listener updatermove = new ByteCartUpdaterMoveListener(); ByteCart.myPlugin.getServer().getPluginManager().registerEvents(updatermove, ByteCart.myPlugin); ByteCartUpdaterMoveListener.setExist(true); } } /** * @param inventory * @param inventory the inventory to set */ @Override public void SetParam(Inventory inventory) { this.inventory = inventory; } } LogUtil.sendSuccess(player, ByteCart.myPlugin.getConfig().getString("Info.RightClickCart") ); new ByteCartInventoryListener(ByteCart.myPlugin, player ,new Execute(player, Wanderer.Level.valueOf(args[0].toUpperCase()), region ,full_reset, isnew) ,true); } return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { if (!(sender instanceof Player)) { if (args.length == 1 && StringUtil.startsWithIgnoreCase("remove", args[0])) { return Lists.newArrayList("remove"); } else { return Collections.emptyList(); } } if (args.length == 1) { List<String> options = Lists.newArrayList("remove"); for (Wanderer.Level level : Wanderer.Level.values()) { options.add(level.name); } return StringUtil.copyPartialMatches(args[0], options, Lists.newArrayList()); } else if (args.length == 2) { if (args[0].equalsIgnoreCase("reset_backbone")) { if (StringUtil.startsWithIgnoreCase("full", args[1])) { return Lists.newArrayList("full"); } } } else if (args.length == 3) { if (args[0].equalsIgnoreCase("region") || args[0].equalsIgnoreCase("local")) { if (StringUtil.startsWithIgnoreCase("new", args[2])) { return Lists.newArrayList("new"); } } else if (args[0].equalsIgnoreCase("reset_region") || args[0].equalsIgnoreCase("reset_local")) { if (StringUtil.startsWithIgnoreCase("full", args[2])) { return Lists.newArrayList("full"); } } } return Collections.emptyList(); } }
5,646
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CommandBCBack.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/CommandBCBack.java
package com.github.catageek.ByteCart.Commands; import java.util.Collections; import java.util.List; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.entity.Player; import com.github.catageek.ByteCart.Signs.BC7017; import com.github.catageek.ByteCart.Util.LogUtil; public class CommandBCBack implements CommandExecutor, TabCompleter { @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (!(sender instanceof Player)) { sender.sendMessage("This command can only be run by a player."); return true; } Player player = (Player) sender; (new BC7017(player.getLocation().getBlock(), player)).trigger(); LogUtil.sendSuccess(player, "Return back"); return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { return Collections.emptyList(); } }
1,025
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractTicketCommand.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Commands/AbstractTicketCommand.java
package com.github.catageek.ByteCart.Commands; import java.util.Collections; import java.util.List; import org.bukkit.ChatColor; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import org.bukkit.util.StringUtil; import com.github.catageek.ByteCart.AddressLayer.AddressString; import com.github.catageek.ByteCartAPI.ByteCartPlugin; import com.google.common.collect.Lists; public abstract class AbstractTicketCommand { protected final ByteCartPlugin plugin; protected AbstractTicketCommand(ByteCartPlugin plugin) { this.plugin = plugin; } /** * Parses command arguments and then calls {@link #run} * * @param sender The entity that called the command * @param player The player to execute on * @param startIndex The index at which to start parsing the address * @param args Arguments to parse from. * @return true if successful */ protected final boolean parse(CommandSender sender, Player player, int startIndex, String[] args) { if (args.length <= startIndex) { return false; } String addressString; boolean isTrain = false; if (args[args.length-1].equalsIgnoreCase("train")) { isTrain = true; addressString = concat(args, startIndex, 1); } else { addressString = concat(args, startIndex, 0); } if (!AddressString.isResolvableAddressOrName(addressString)) { sender.sendMessage(ChatColor.DARK_GREEN + "[Bytecart] " + ChatColor.RED + "No valid destination supplied."); return false; } return run(sender, player, addressString, isTrain); } /** * Gets a list of possible tab completion options. */ protected final List<String> tabComplete(int startIndex, String[] args) { if (args.length <= startIndex) { return Collections.emptyList(); } String written = concat(args, startIndex, 1); List<String> options = Lists.newArrayList(); if (plugin.getResolver() != null) { String prefix = concat(args, startIndex, 0); List<String> names = plugin.getResolver().getMatchingNames(prefix); for (String name : names) { name = name.substring(prefix.length()); if (name.contains(" ")) { name = name.substring(0, name.indexOf(' ')); } options.add(name); } } if (StringUtil.startsWithIgnoreCase("train", args[args.length - 1])) { if (AddressString.isResolvableAddressOrName(written)) { options.add("train"); } } return options; } /** * Performs actual command logic. * * @param sender The entity that called the command * @param player The player to execute on * @param addressString The address parsed from command arguments * @param isTrain True if this is a train * @return true if successful */ protected abstract boolean run(CommandSender sender, Player player, String addressString, boolean isTrain); private static String concat(String[] s, int first, int omitted) { if (s.length <= first) { return ""; } String ret = s[first]; for (int i = first + 1; i < s.length - omitted; ++i) { ret += " "; ret += s[i]; } return ret; } }
3,026
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RightRouter.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/RightRouter.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCartAPI.Util.DirectionRegistry; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * A router where the cart turns right */ final class RightRouter extends AbstractRouter implements Router { RightRouter(BlockFace from, org.bukkit.Location loc, boolean b) { super(from, loc, b); FromTo.put(Side.BACK, Side.RIGHT); FromTo.put(Side.LEFT, Side.LEFT); FromTo.put(Side.STRAIGHT, Side.STRAIGHT); FromTo.put(Side.RIGHT, Side.BACK); setSecondpos(Integer.parseInt("00101001", 2)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractRouter#route(org.bukkit.block.BlockFace) */ @Override public void route(BlockFace from) { // activate main levers this.getOutput(0).setAmount((new DirectionRegistry(MathUtil.anticlockwise(from))).getAmount()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractRouter#getTo() */ @Override public BlockFace getTo() { return MathUtil.anticlockwise(this.getFrom()); } }
1,138
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CollisionAvoider.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/CollisionAvoider.java
package com.github.catageek.ByteCart.CollisionManagement; import com.github.catageek.ByteCart.Signs.Triggable; /** * A state machine depending of 2 elements */ interface CollisionAvoider { /** * Get the value stored as second pos * * @return the value of the second position */ public int getSecondpos(); /** * Add the second triggered IC to current CollisonAvoider * * * @param t */ public void Add(Triggable t); }
445
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/package-info.java
/** * */ /** * This package provides classes for collision management */ package com.github.catageek.ByteCart.CollisionManagement;
135
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
LeftRouter.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/LeftRouter.java
package com.github.catageek.ByteCart.CollisionManagement; import java.util.EnumSet; import java.util.Set; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * A router where a cart turns left */ final class LeftRouter extends AbstractRouter implements Router { LeftRouter(BlockFace from, org.bukkit.Location loc, boolean b) { super(from, loc, b); FromTo.put(Side.BACK, Side.LEFT); Set<Side> left = EnumSet.of(Side.LEFT, Side.STRAIGHT, Side.RIGHT); Possibility.put(Side.LEFT, left); Set<Side> straight = EnumSet.of(Side.STRAIGHT, Side.LEFT, Side.BACK); Possibility.put(Side.STRAIGHT, straight); Set<Side> right = EnumSet.of(Side.LEFT, Side.BACK); Possibility.put(Side.RIGHT, right); setSecondpos(Integer.parseInt("01000000", 2)); setPosmask(Integer.parseInt("11100000", 2)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractRouter#getTo() */ @Override public BlockFace getTo() { return MathUtil.clockwise(this.getFrom()); } }
1,055
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BackRouter.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/BackRouter.java
package com.github.catageek.ByteCart.CollisionManagement; import java.util.EnumSet; import java.util.Set; import org.bukkit.block.BlockFace; /** * A router where the cart goes back */ final class BackRouter extends AbstractRouter implements Router { BackRouter(BlockFace from, org.bukkit.Location loc, boolean b) { super(from, loc, b); FromTo.put(Side.BACK, Side.BACK); Set<Side> left = EnumSet.of(Side.BACK, Side.LEFT); Possibility.put(Side.LEFT, left); Set<Side> straight = EnumSet.of(Side.RIGHT, Side.LEFT, Side.BACK); Possibility.put(Side.STRAIGHT, straight); Set<Side> right = EnumSet.of(Side.STRAIGHT, Side.BACK, Side.RIGHT); Possibility.put(Side.RIGHT, right); setSecondpos(Integer.parseInt("10000000", 2)); setPosmask(Integer.parseInt("11000001", 2)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractRouter#getTo() */ @Override public final BlockFace getTo() { return this.getFrom(); } }
982
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractRouter.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/AbstractRouter.java
package com.github.catageek.ByteCart.CollisionManagement; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import org.bukkit.Location; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.HAL.PinRegistry; import com.github.catageek.ByteCart.IO.OutputPin; import com.github.catageek.ByteCart.IO.OutputPinFactory; import com.github.catageek.ByteCart.Signs.Triggable; import com.github.catageek.ByteCart.Storage.ExpirableMap; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; import com.github.catageek.ByteCartAPI.Util.MathUtil; abstract class AbstractRouter extends AbstractCollisionAvoider implements Router { private static final ExpirableMap<Location, Boolean> recentlyUsedMap = new ExpirableMap<Location, Boolean>(40, false, "recentlyUsedRouter"); private static final ExpirableMap<Location, Boolean> hasTrainMap = new ExpirableMap<Location, Boolean>(14, false, "hasTrainRouter"); private BlockFace From; protected Map<Side, Side> FromTo = new ConcurrentHashMap<Side, Side>(); protected Map<Side, Set<Side>> Possibility = new ConcurrentHashMap<Side, Set<Side>>(); private int secondpos = 0; private int posmask = 255; private boolean IsOldVersion; AbstractRouter(BlockFace from, org.bukkit.Location loc, boolean isOldVersion) { super(loc); this.setFrom(from); this.IsOldVersion = isOldVersion; this.addIO(from, loc.getBlock()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.CollisionAvoider#Add(com.github.catageek.ByteCart.Signs.Triggable) */ @Override public void Add(Triggable t) { return; } /** * @return the isOldVersion */ private boolean isIsOldVersion() { return IsOldVersion; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#WishToGo(org.bukkit.block.BlockFace, org.bukkit.block.BlockFace, boolean) */ @Override public final BlockFace WishToGo(BlockFace from, BlockFace to, boolean isTrain) { // IntersectionSide sfrom = getSide(from); // IntersectionSide sto = getSide(to); if(ByteCart.debug) ByteCart.log.info("ByteCart : Router : coming from " + from + " going to " + to); /* if(ByteCart.debug) ByteCart.log.info("ByteCart : Router : going to " + sto); */ Router ca = this; /* if(ByteCart.debug) { ByteCart.log.info("ByteCart : position found " + ca.getClass().toString()); ByteCart.log.info("ByteCart : Recently used ? " + recentlyUsed); ByteCart.log.info("ByteCart : hasTrain ? " + hasTrain ); ByteCart.log.info("ByteCart : isTrain ? " + isTrain ); } */ Side s = getSide(from, to); boolean cond = !this.getRecentlyUsed() && !this.getHasTrain(); if (this.getPosmask() != 255 || cond) { switch(s) { case STRAIGHT: ca = new StraightRouter(from, getLocation(), this.isIsOldVersion()); if ( (cond) || this.ValidatePosition(ca)) break; case RIGHT: ca = new RightRouter(from, getLocation(), this.isIsOldVersion()); if ( (cond) || this.ValidatePosition(ca)) break; case LEFT: ca = new LeftRouter(from, getLocation(), this.isIsOldVersion()); if ( (cond) || this.ValidatePosition(ca)) break; case BACK: ca = new BackRouter(from, getLocation(), this.isIsOldVersion()); if ( (cond) || this.ValidatePosition(ca)) break; default: ca = new LeftRouter(from, getLocation(), this.isIsOldVersion()); if ( (cond) || this.ValidatePosition(ca)) break; ca = this; } /* if(ByteCart.debug) ByteCart.log.info("ByteCart : Router : position changed to " + ca.getClass().toString()); if(ByteCart.debug) ByteCart.log.info("ByteCart : Router : really going to " + ca.getTo()); */ // save router in collision avoider map ByteCart.myPlugin.getCollisionAvoiderManager().setCollisionAvoider(this.getLocation(), ca); // activate secondary levers ca.getOutput(1).setAmount(ca.getSecondpos()); ca.getOutput(2).setAmount(ca.getSecondpos()); //activate primary levers ca.route(from); } ca.Book(isTrain); return ca.getTo(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#route(org.bukkit.block.BlockFace) */ @Override public void route(BlockFace from) { return; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#getTo() */ @Override public abstract BlockFace getTo(); /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#getFrom() */ @Override public final BlockFace getFrom() { return From; } /** * Tell if a transition is necessary for the router to satisfy direction request * * @param ca the collision avoider against which to check the state * @return false if a transition is needed */ private final boolean ValidatePosition(Router ca) { Side side = getSide(this.getFrom(), ca.getFrom()); if(ByteCart.debug) ByteCart.log.info("ByteCart : pos value befor rotation : " + Integer.toBinaryString(getSecondpos())); if(ByteCart.debug) ByteCart.log.info("ByteCart : rotation of bits : " + side.Value()); int value = AbstractRouter.leftRotate8(getSecondpos(), side.Value()); if(ByteCart.debug) ByteCart.log.info("ByteCart : pos value after rotation : " + Integer.toBinaryString(value)); int mask = AbstractRouter.leftRotate8(getPosmask(), side.Value()); if(ByteCart.debug) ByteCart.log.info("ByteCart : mask after rotation : " + Integer.toBinaryString(mask)); ca.setSecondpos(value | ca.getSecondpos()); if(ByteCart.debug) ByteCart.log.info("ByteCart : value after OR : " + Integer.toBinaryString(ca.getSecondpos())); ca.setPosmask(mask | ca.getPosmask()); if(ByteCart.debug) ByteCart.log.info("ByteCart : mask after OR : " + Integer.toBinaryString(ca.getPosmask())); if(ByteCart.debug) ByteCart.log.info("ByteCart : compatible ? : " + (((value ^ ca.getSecondpos()) & mask) == 0)); return ((value ^ ca.getSecondpos()) & mask) == 0; } /** * @param from the from to set */ private final void setFrom(BlockFace from) { From = from; } /** * Get the relative direction of an absolute direction * * @param to the absolute direction * @return the relative direction */ @SuppressWarnings("unused") private final Side getSide(BlockFace to) { return getSide(getFrom(), to); } /** * Get the relative direction of an absolute direction with a specific origin * * @param from the origin axis * @param to the absolute direction * @return the relative direction */ private final static Side getSide(BlockFace from, BlockFace to) { BlockFace t = to; if (from == t) return Side.BACK; t = turn(t); if (from == t) return Side.LEFT; t = turn(t); if (from == t) return Side.STRAIGHT; return Side.RIGHT; } /** * Get the next absolute direction on the left * * @param b the initial direction * @return the next direction */ private final static BlockFace turn(BlockFace b) { return MathUtil.anticlockwise(b); } /** * Registers levers as output * * @param from the origin axis * @param center the center of the router */ private final void addIO(BlockFace from, org.bukkit.block.Block center) { BlockFace f = from; BlockFace g = MathUtil.clockwise(from); // Main output OutputPin[] sortie = new OutputPin[4]; if(this.isIsOldVersion()) { // East sortie[0] = OutputPinFactory.getOutput(center.getRelative(BlockFace.WEST,3).getRelative(BlockFace.SOUTH)); // North sortie[1] = OutputPinFactory.getOutput(center.getRelative(BlockFace.EAST,3).getRelative(BlockFace.NORTH)); // South sortie[3] = OutputPinFactory.getOutput(center.getRelative(BlockFace.SOUTH,3).getRelative(BlockFace.EAST)); // West sortie[2] = OutputPinFactory.getOutput(center.getRelative(BlockFace.NORTH,3).getRelative(BlockFace.WEST)); } else { // East sortie[0] = OutputPinFactory.getOutput(center.getRelative(BlockFace.SOUTH,3).getRelative(BlockFace.EAST)); // North sortie[1] = OutputPinFactory.getOutput(center.getRelative(BlockFace.NORTH,3).getRelative(BlockFace.WEST)); // South sortie[3] = OutputPinFactory.getOutput(center.getRelative(BlockFace.WEST,3).getRelative(BlockFace.SOUTH)); // West sortie[2] = OutputPinFactory.getOutput(center.getRelative(BlockFace.EAST,3).getRelative(BlockFace.NORTH)); } checkIOPresence(sortie); RegistryOutput main = new PinRegistry<OutputPin>(sortie); // output[0] is main levers this.addOutputRegistry(main); // Secondary output to make U-turn OutputPin[] secondary = new OutputPin[8]; // Alternate secondary output to make U-turn (for new BC8011 router) OutputPin[] altsecond = new OutputPin[8]; for (int i=0; i<7; i++) { // the first is Back altsecond[i] = OutputPinFactory.getOutput(center.getRelative(f, 3).getRelative(g, 1)); secondary[i++] = OutputPinFactory.getOutput(center.getRelative(f, 4).getRelative(g, 2)); altsecond[i] = OutputPinFactory.getOutput(center.getRelative(f, 5).getRelative(g, 1)); secondary[i] = OutputPinFactory.getOutput(center.getRelative(f, 6)); f = g; g = MathUtil.clockwise(g); } checkIOPresence(secondary, altsecond); RegistryOutput second = new PinRegistry<OutputPin>(secondary); RegistryOutput altsec = new PinRegistry<OutputPin>(altsecond); // output[1] is second and third levers this.addOutputRegistry(second); // output[2] is alternate second and third levers this.addOutputRegistry(altsec); } /** * Check if there are levers as expected * * @param secondary an array of levers * @param altsecond alternative array of levers */ private void checkIOPresence(OutputPin[] secondary, OutputPin[] altsecond) { for (int i = 0; i < secondary.length; i++) if (secondary[i] == null && altsecond[i] == null) { ByteCart.log.log(java.util.logging.Level.SEVERE, "ByteCart : Lever missing or wrongly positioned in router " + this.getLocation()); throw new NullPointerException(); } } /** * Check if there are levers as expected * * @param sortie an array of levers */ private void checkIOPresence(OutputPin[] sortie) { for (int i = 0; i < sortie.length; i++) if (sortie[i] == null) { ByteCart.log.log(java.util.logging.Level.SEVERE, "ByteCart : Lever missing or wrongly positioned in router " + this.getLocation()); throw new NullPointerException(); } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#getSecondpos() */ @Override public final int getSecondpos() { return secondpos; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#getPosmask() */ @Override public final int getPosmask() { return posmask; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#setPosmask(int) */ @Override public final void setPosmask(int posmask) { this.posmask = posmask; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.Router#setSecondpos(int) */ @Override public final void setSecondpos(int secondpos) { this.secondpos = secondpos; } /** * Bit-rotate a value on 8 bits * * @param value the value to rotate * @param d the numbers of bits to shift left * @return the result */ private final static int leftRotate8(int value, int d) { int b = 8 - d; return (value >> (b)) | ((value & ((1 << b) - 1)) << d); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractCollisionAvoider#getRecentlyUsedMap() */ @Override protected ExpirableMap<Location, Boolean> getRecentlyUsedMap() { return recentlyUsedMap; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractCollisionAvoider#getHasTrainMap() */ @Override protected ExpirableMap<Location, Boolean> getHasTrainMap() { return hasTrainMap; } }
11,970
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RouterCollisionAvoiderBuilder.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/RouterCollisionAvoiderBuilder.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.Signs.Triggable; /** * A builder for router collision avoider */ public class RouterCollisionAvoiderBuilder extends AbstractCollisionAvoiderBuilder implements CollisionAvoiderBuilder { private boolean IsOldVersion; public RouterCollisionAvoiderBuilder(Triggable ic, Location loc, boolean isOldVersion) { super(ic, loc); this.IsOldVersion = isOldVersion; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.CollisionAvoiderBuilder#getCollisionAvoider() */ @SuppressWarnings("unchecked") @Override public <T extends CollisionAvoider> T getCollisionAvoider() { return (T) new StraightRouter (this.ic.getCardinal().getOppositeFace(), this.loc, this.IsOldVersion); } }
837
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
SimpleCollisionAvoiderBuilder.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/SimpleCollisionAvoiderBuilder.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.Signs.Triggable; /** * A builder for simple collision avoider, i.e for a T cross-roads */ public class SimpleCollisionAvoiderBuilder extends AbstractCollisionAvoiderBuilder implements CollisionAvoiderBuilder { public SimpleCollisionAvoiderBuilder(Triggable ic, Location loc) { super(ic, loc); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.CollisionAvoiderBuilder#getCollisionAvoider() */ @Override @SuppressWarnings("unchecked") public <T extends CollisionAvoider> T getCollisionAvoider() { return (T) new SimpleCollisionAvoider (this.ic, this.loc); } }
734
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Router.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/Router.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; /** * A router representation in the collision management layer */ public interface Router extends CollisionAvoider { /** * Ask for a direction, requesting a possible transition * * @param from the direction from where comes the cart * @param to the direction where the cart goes to * @param isTrain true if it is a train * @return the direction actually taken */ public <T extends Router> BlockFace WishToGo(BlockFace from, BlockFace to, boolean isTrain); /** * Book the router, i.e mark it as currently in use * * @param b true if this is a train */ public void Book(boolean b); /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.CollisionAvoider#getSecondpos() */ @Override public int getSecondpos() ; /** * Get the mask of the current usage of the router, starting from the origin axis. * * <p>a bit to 1 means the lever is blocked, a bit to 0 means the lever is not blocked</p> * * @return the mask */ public int getPosmask() ; /** * Set the mask of the current usage of the router, starting from the origin axis. * * <p>a bit to 1 means the lever is blocked, a bit to 0 means the lever is not blocked</p> * * @param posmask the mask to set */ public void setPosmask(int posmask) ; /** * Set the value of the position of the 8 exterior levers, starting from the origin axis. * * <p>a bit to 1 means the lever is on, a bit to 0 means the lever is off</p> * * @param secondpos the value to set */ public void setSecondpos(int secondpos) ; /** * Get the direction from where the cart is coming. * * <p>This direction is also the origin axis of the registries</p> * * * @return the direction */ public BlockFace getFrom(); /** * Activate levers according to registry * * * @param from the origin direction */ public void route(BlockFace from); /** * Get the lever registry * * @param i 0 for main levers, 1 for secondary levers * @return the value of the registry */ public RegistryOutput getOutput(int i); /** * Get the direction where the cart eventually go * * * @return the direction */ public BlockFace getTo(); }
2,333
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CollisionAvoiderManager.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/CollisionAvoiderManager.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.Storage.ExpirableMap; /** * Manage the persistence of collision avoiders */ public final class CollisionAvoiderManager { /** * The map where collision avoiders are stored for 4 seconds */ private final ExpirableMap<Location, CollisionAvoider> manager = new ExpirableMap<Location, CollisionAvoider>(40, false, "CollisionAvoider"); /** * Get the map * * @return the map */ private ExpirableMap<Location, CollisionAvoider> getManager() { return manager; } /** * Get an existing collision avoider, or create one * * @param builder a class providing an instance of the collision avoider * @return the collision avoider */ @SuppressWarnings("unchecked") public final synchronized <T extends CollisionAvoider> T getCollisionAvoider(CollisionAvoiderBuilder builder) { Location loc = builder.getLocation(); T cm; // Get an instance from the map cm = (T) this.getManager().get(loc); if(cm != null) { // if a collision avoider exists, attach itself as second IC cm.Add(builder.getIc()); this.getManager().reset(loc); } else { // Get a new instance cm = builder.<T>getCollisionAvoider(); // store the instance in the map this.getManager().put(loc, cm); } return cm; } /** * Set or replace the collision avoider stored at a specific location * * @param loc the location * @param ca the collision avoider to store */ final void setCollisionAvoider(Location loc, CollisionAvoider ca) { this.getManager().put(loc, ca); } }
1,632
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
SimpleCollisionAvoider.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/SimpleCollisionAvoider.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.Signs.Triggable; import com.github.catageek.ByteCart.Storage.ExpirableMap; import com.github.catageek.ByteCartAPI.CollisionManagement.IntersectionSide; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; /** * A collision avoider for T cross-roads */ public class SimpleCollisionAvoider extends AbstractCollisionAvoider implements CollisionAvoider { private static final ExpirableMap<Location, Boolean> recentlyUsedMap = new ExpirableMap<Location, Boolean>(20, false, "recentlyUsed9000"); private static final ExpirableMap<Location, Boolean> hasTrainMap = new ExpirableMap<Location, Boolean>(14, false, "hastrain"); private RegistryOutput Lever1 = null, Lever2 = null, Active = null; private final Location loc1; private IntersectionSide.Side state; private boolean reversed; SimpleCollisionAvoider(Triggable ic, org.bukkit.Location loc) { super(loc); if(ByteCart.debug) ByteCart.log.info("ByteCart: new IntersectionSide() at " + loc); Lever1 = ic.getOutput(0); Active = Lever1; reversed = ic.isLeverReversed(); loc1 = ic.getLocation(); state = (Lever1.getAmount() == 0 ? IntersectionSide.Side.LEVER_OFF : IntersectionSide.Side.LEVER_ON); } /** * Ask for a direction, requesting a possible transition * * @param s the direction where the cart goes to * @param isTrain true if it is a train * @return the direction actually taken */ public IntersectionSide.Side WishToGo(IntersectionSide.Side s, boolean isTrain) { IntersectionSide.Side trueside = getActiveTrueSide(s); if(ByteCart.debug) ByteCart.log.info("ByteCart : WishToGo to side " + trueside + " and isTrain is " + isTrain); if(ByteCart.debug) ByteCart.log.info("ByteCart : state is " + state); if(ByteCart.debug) ByteCart.log.info("ByteCart : recentlyUsed is " + this.getRecentlyUsed() + " and hasTrain is " + this.getHasTrain()); if(ByteCart.debug) ByteCart.log.info("ByteCart : Lever1 is " + Lever1.getAmount()); if ( trueside != state && (Lever2 == null || ( !this.getRecentlyUsed()) && !this.getHasTrain())) { Set(trueside); } this.setRecentlyUsed(true); return state; } /** * Get the fixed side of the active lever. * the second IC lever can be reversed * * @param s the original side * @return the fixed side */ private final IntersectionSide.Side getActiveTrueSide(IntersectionSide.Side s) { if (Active != Lever2) return s; return getSecondLeverSide(s); } /** * Get the fixed side of the second lever * @param s the original side * @return the fixed side */ private final IntersectionSide.Side getSecondLeverSide(IntersectionSide.Side s) { return reversed ? s : s.opposite(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.CollisionAvoider#Add(com.github.catageek.ByteCart.Signs.Triggable) */ @Override public void Add(Triggable t) { if (t.getLocation().equals(loc1)) { Active = Lever1; return; } if (Lever2 != null) { Active = Lever2; return; } Lever2 = t.getOutput(0); Active = Lever2; reversed ^= t.isLeverReversed(); Lever2.setAmount(getSecondLeverSide(state).Value()); if(ByteCart.debug) ByteCart.log.info("ByteCart: Add and setting lever2 to " + Lever2.getAmount()); } /** * Activate levers. The 2 levers are in opposition * * @param s the side of the lever of the IC that created this collision avoider */ private void Set(IntersectionSide.Side s) { this.Lever1.setAmount(s.Value()); if(ByteCart.debug) ByteCart.log.info("ByteCart: Setting lever1 to " + Lever1.getAmount()); if (this.Lever2 != null) { this.Lever2.setAmount(getSecondLeverSide(state).Value()); if(ByteCart.debug) ByteCart.log.info("ByteCart: Setting lever2 to " + Lever2.getAmount()); } state = s; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.CollisionAvoider#getSecondpos() */ @Override public int getSecondpos() { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractCollisionAvoider#getRecentlyUsedMap() */ @Override protected ExpirableMap<Location, Boolean> getRecentlyUsedMap() { return recentlyUsedMap; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractCollisionAvoider#getHasTrainMap() */ @Override protected ExpirableMap<Location, Boolean> getHasTrainMap() { return hasTrainMap; } }
4,620
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
StraightRouter.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/StraightRouter.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCartAPI.Util.DirectionRegistry; /** * A router where the cart goes straight */ class StraightRouter extends AbstractRouter implements Router { StraightRouter(BlockFace from, org.bukkit.Location loc, boolean isOldVersion) { super(from, loc, isOldVersion); FromTo.put(Side.BACK, Side.STRAIGHT); FromTo.put(Side.LEFT, Side.LEFT); FromTo.put(Side.STRAIGHT, Side.RIGHT); FromTo.put(Side.RIGHT, Side.BACK); setSecondpos(Integer.parseInt("00100101", 2)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractRouter#route(org.bukkit.block.BlockFace) */ @Override public void route(BlockFace from) { // activate main levers this.getOutput(0).setAmount((new DirectionRegistry(from.getOppositeFace())).getAmount()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.CollisionManagement.AbstractRouter#getTo() */ @Override public final BlockFace getTo() { return this.getFrom().getOppositeFace(); } }
1,097
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractCollisionAvoiderBuilder.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/AbstractCollisionAvoiderBuilder.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.Signs.Triggable; /** * Abstract class for colllision avoider builders */ abstract class AbstractCollisionAvoiderBuilder { /** * The first IC attached to the collision avoiders created */ protected final Triggable ic; /** * The location to where the collision avoiders will be attached */ protected final Location loc; AbstractCollisionAvoiderBuilder(Triggable ic, Location loc) { this.ic = ic; this.loc = loc; } /** * Get the location to where the collision avoiders created will be attached * * @return the location */ public Location getLocation() { return this.loc; } /** * Get the IC to which the collision avoiders created will be attached * * * @return the IC */ public Triggable getIc() { return ic; } }
890
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
CollisionAvoiderBuilder.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/CollisionAvoiderBuilder.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.Signs.Triggable; /** * A builder for a collision manager */ public interface CollisionAvoiderBuilder { /** * Get an instance of the collision manager * * @return an instance of collision manager */ public <T extends CollisionAvoider> T getCollisionAvoider(); /** * Get the location to where the collision managers built will be attached * * * @return the location */ public Location getLocation(); /** * Get the IC attached to the collision managers built * * * @return the IC */ public Triggable getIc(); }
670
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractCollisionAvoider.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/CollisionManagement/AbstractCollisionAvoider.java
package com.github.catageek.ByteCart.CollisionManagement; import org.bukkit.Location; import com.github.catageek.ByteCart.HAL.AbstractIC; import com.github.catageek.ByteCart.Storage.ExpirableMap; /** * Abstract class for collision avoiders */ abstract class AbstractCollisionAvoider extends AbstractIC { /** * Get a map of locations that have been recently used * * @return the map */ abstract protected ExpirableMap<Location, Boolean> getRecentlyUsedMap(); /** * Get a map of locations that have the train flag * * * @return the map */ abstract protected ExpirableMap<Location, Boolean> getHasTrainMap(); /** * Relative direction for the router. BACK is the direction from where the cart is arriving */ enum Side { BACK (0), LEFT (2), STRAIGHT (4), RIGHT(6); private int Value; Side(int b) { Value = b; } int Value() { return Value; } } /** * @param loc the location where the collision avoider will be attached */ AbstractCollisionAvoider(org.bukkit.Location loc) { super(loc.getBlock()); } /** * Tell if this collision avoider has the train flag set * * @return true if the flag is set */ protected boolean getHasTrain() { return this.getHasTrainMap().contains(getLocation()); } /** * Tell if this collision avoider has been recently used * * @return true if recently used */ protected boolean getRecentlyUsed() { return this.getRecentlyUsedMap().contains(getLocation()); } /** * @param hasTrain the hasTrain to set */ private void setHasTrain(boolean hasTrain) { this.getHasTrainMap().put(getLocation(), hasTrain); } /** * @param recentlyUsed the recentlyUsed to set */ protected void setRecentlyUsed(boolean recentlyUsed) { this.getRecentlyUsedMap().put(getLocation(), recentlyUsed); } /** * {@link Router#Book(boolean)} */ public void Book(boolean isTrain) { setRecentlyUsed(true); setHasTrain(this.getHasTrain() | isTrain); } @Override public final String getName() { return "Collision avoider"; } @Override public final String getFriendlyName() { return getName(); } }
2,129
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
LogUtil.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Util/LogUtil.java
package com.github.catageek.ByteCart.Util; import org.bukkit.ChatColor; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import com.github.catageek.ByteCart.ByteCart; public final class LogUtil { public static void sendError(CommandSender sender, String message) { display(sender, ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED + message); } public static void sendSuccess(CommandSender sender, String message) { display(sender, ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.YELLOW + message); } private static void display(CommandSender sender, String message) { if (sender != null && (sender instanceof Player) && ((Player) sender).isOnline()) sender.sendMessage(message); else ByteCart.log.info(ChatColor.stripColor(message)); } }
790
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Base64.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Util/Base64.java
package com.github.catageek.ByteCart.Util; import java.util.Arrays; public class Base64 { private static final char[] CA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray(); private static final int[] IA = new int[256]; static { Arrays.fill(IA, -1); for (int i = 0, iS = CA.length; i < iS; i++) IA[CA[i]] = i; IA['='] = 0; } private final static char[] encodeToChar(byte[] sArr, boolean lineSep) { // Check special case int sLen = sArr != null ? sArr.length : 0; if (sLen == 0) return new char[0]; int eLen = (sLen / 3) * 3; // Length of even 24-bits. int cCnt = ((sLen - 1) / 3 + 1) << 2; // Returned character count int dLen = cCnt + (lineSep ? (cCnt - 1) / 76 << 1 : 0); // Length of returned array char[] dArr = new char[dLen]; // Encode even 24-bits for (int s = 0, d = 0, cc = 0; s < eLen;) { // Copy next three bytes into lower 24 bits of int, paying attension to sign. int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff); // Encode the int into four chars dArr[d++] = CA[(i >>> 18) & 0x3f]; dArr[d++] = CA[(i >>> 12) & 0x3f]; dArr[d++] = CA[(i >>> 6) & 0x3f]; dArr[d++] = CA[i & 0x3f]; // Add optional line separator if (lineSep && ++cc == 19 && d < dLen - 2) { dArr[d++] = '\r'; dArr[d++] = '\n'; cc = 0; } } // Pad and encode last bits if source isn't even 24 bits. int left = sLen - eLen; // 0 - 2. if (left > 0) { // Prepare the int int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0); // Set last four chars dArr[dLen - 4] = CA[i >> 12]; dArr[dLen - 3] = CA[(i >>> 6) & 0x3f]; dArr[dLen - 2] = left == 2 ? CA[i & 0x3f] : '='; dArr[dLen - 1] = '='; } return dArr; } public final static byte[] encodeToByte(byte[] sArr, boolean lineSep) { // Check special case int sLen = sArr != null ? sArr.length : 0; if (sLen == 0) return new byte[0]; int eLen = (sLen / 3) * 3; // Length of even 24-bits. int cCnt = ((sLen - 1) / 3 + 1) << 2; // Returned character count int dLen = cCnt + (lineSep ? (cCnt - 1) / 76 << 1 : 0); // Length of returned array byte[] dArr = new byte[dLen]; // Encode even 24-bits for (int s = 0, d = 0, cc = 0; s < eLen;) { // Copy next three bytes into lower 24 bits of int, paying attension to sign. int i = (sArr[s++] & 0xff) << 16 | (sArr[s++] & 0xff) << 8 | (sArr[s++] & 0xff); // Encode the int into four chars dArr[d++] = (byte) CA[(i >>> 18) & 0x3f]; dArr[d++] = (byte) CA[(i >>> 12) & 0x3f]; dArr[d++] = (byte) CA[(i >>> 6) & 0x3f]; dArr[d++] = (byte) CA[i & 0x3f]; // Add optional line separator if (lineSep && ++cc == 19 && d < dLen - 2) { dArr[d++] = '\r'; dArr[d++] = '\n'; cc = 0; } } // Pad and encode last bits if source isn't an even 24 bits. int left = sLen - eLen; // 0 - 2. if (left > 0) { // Prepare the int int i = ((sArr[eLen] & 0xff) << 10) | (left == 2 ? ((sArr[sLen - 1] & 0xff) << 2) : 0); // Set last four chars dArr[dLen - 4] = (byte) CA[i >> 12]; dArr[dLen - 3] = (byte) CA[(i >>> 6) & 0x3f]; dArr[dLen - 2] = left == 2 ? (byte) CA[i & 0x3f] : (byte) '='; dArr[dLen - 1] = '='; } return dArr; } public final static String encodeToString(byte[] sArr, boolean lineSep) { // Reuse char[] since we can't create a String incrementally anyway and StringBuffer/Builder would be slower. return new String(encodeToChar(sArr, lineSep)); } public final static byte[] decodeFast(String s) { // Check special case int sLen = s.length(); if (sLen == 0) return new byte[0]; int sIx = 0, eIx = sLen - 1; // Start and end index after trimming. // Trim illegal chars from start while (sIx < eIx && IA[s.charAt(sIx) & 0xff] < 0) sIx++; // Trim illegal chars from end while (eIx > 0 && IA[s.charAt(eIx) & 0xff] < 0) eIx--; // get the padding count (=) (0, 1 or 2) int pad = s.charAt(eIx) == '=' ? (s.charAt(eIx - 1) == '=' ? 2 : 1) : 0; // Count '=' at end. int cCnt = eIx - sIx + 1; // Content count including possible separators int sepCnt = sLen > 76 ? (s.charAt(76) == '\r' ? cCnt / 78 : 0) << 1 : 0; int len = ((cCnt - sepCnt) * 6 >> 3) - pad; // The number of decoded bytes byte[] dArr = new byte[len]; // Preallocate byte[] of exact length // Decode all but the last 0 - 2 bytes. int d = 0; for (int cc = 0, eLen = (len / 3) * 3; d < eLen;) { // Assemble three bytes into an int from four "valid" characters. int i = IA[s.charAt(sIx++)] << 18 | IA[s.charAt(sIx++)] << 12 | IA[s.charAt(sIx++)] << 6 | IA[s.charAt(sIx++)]; // Add the bytes dArr[d++] = (byte) (i >> 16); dArr[d++] = (byte) (i >> 8); dArr[d++] = (byte) i; // If line separator, jump over it. if (sepCnt > 0 && ++cc == 19) { sIx += 2; cc = 0; } } if (d < len) { // Decode last 1-3 bytes (incl '=') into 1-3 bytes int i = 0; for (int j = 0; sIx <= eIx - pad; j++) i |= IA[s.charAt(sIx++)] << (18 - j * 6); for (int r = 16; d < len; r -= 8) dArr[d++] = (byte) (i >> r); } return dArr; } }
5,218
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ComponentButton.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/ComponentButton.java
package com.github.catageek.ByteCart.IO; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import org.bukkit.Location; import org.bukkit.block.Block; import org.bukkit.block.data.BlockData; import org.bukkit.block.data.Powerable; import org.bukkit.block.data.type.Switch; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * A button */ class ComponentButton extends AbstractComponent implements OutputPin, InputPin { final static private Map<Location, Integer> ActivatedButtonMap = new ConcurrentHashMap<Location, Integer>(); /** * @param block the block containing the component */ protected ComponentButton(Block block) { super(block); /* if(ByteCart.debug) ByteCart.log.info("ByteCart : adding Button at " + block.getLocation().toString()); */ } /* (non-Javadoc) * @see com.github.catageek.ByteCart.IO.OutputPin#write(boolean) */ @Override public void write(boolean bit) { final Block block = this.getBlock(); final BlockData blockdata = block.getBlockData(); if(blockdata instanceof Switch) { final ComponentButton component = this; int id; final Switch button = (Switch) block.getBlockData(); if (bit) { if (ActivatedButtonMap.containsKey(block)) { // if button is already on, we cancel the scheduled thread ByteCart.myPlugin.getServer().getScheduler().cancelTask(ActivatedButtonMap.get(block)); // and we reschedule one id = ByteCart.myPlugin.getServer().getScheduler().scheduleSyncDelayedTask(ByteCart.myPlugin, new SetButtonOff(component, ActivatedButtonMap) , 40); // We update the HashMap ActivatedButtonMap.put(block.getLocation(), id); } else { // if button is off, we power the button button.setPowered(true); block.setBlockData(button); MathUtil.forceUpdate(block.getRelative(button.getFacing().getOppositeFace())); // delayed action to unpower the button after 2 s. id = ByteCart.myPlugin.getServer().getScheduler().scheduleSyncDelayedTask(ByteCart.myPlugin, new SetButtonOff(component, ActivatedButtonMap) , 40); // We update the HashMap ActivatedButtonMap.put(block.getLocation(), id); } } } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.IO.InputPin#read() */ @Override public boolean read() { final BlockData md = this.getBlock().getBlockData(); if(md instanceof Powerable) { return ((Powerable) md).isPowered(); } return false; } }
2,563
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
SetButtonOff.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/SetButtonOff.java
package com.github.catageek.ByteCart.IO; import java.util.Map; import org.bukkit.Location; import org.bukkit.block.Block; import org.bukkit.block.data.type.Switch; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * this call represents a thread that powers off a button */ class SetButtonOff implements Runnable { final private Component component; final private Map<Location, Integer> ActivatedButtonMap; /** * @param component the component to power off * @param ActivatedButtonMap a map containing the task id of current task */ SetButtonOff(Component component, Map<Location, Integer> ActivatedButtonMap){ this.component = component; this.ActivatedButtonMap = ActivatedButtonMap; } /* (non-Javadoc) * @see java.lang.Runnable#run() */ @Override public void run() { final Block block = component.getBlock(); if (block.getBlockData() instanceof Switch) { final Switch button = (Switch) block.getBlockData(); button.setPowered(false); block.setBlockData(button); MathUtil.forceUpdate(block.getRelative(button.getFacing().getOppositeFace())); } ActivatedButtonMap.remove(block.getLocation()); } }
1,161
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractComponent.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/AbstractComponent.java
package com.github.catageek.ByteCart.IO; import org.bukkit.block.Block; /** * Abstract class containing common methods for all components */ public abstract class AbstractComponent implements Component { private final Block block; /** * @param block the block containing the component */ protected AbstractComponent(Block block) { this.block = block; } /** * @return the block */ @Override public Block getBlock() { return block; } }
461
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/package-info.java
/** * */ /** * This package contains all classes for accessing in-game components */ package com.github.catageek.ByteCart.IO;
130
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
OutputPinFactory.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/OutputPinFactory.java
package com.github.catageek.ByteCart.IO; import org.bukkit.Material; import org.bukkit.block.Block; import org.bukkit.block.data.type.Switch; /** * Factory to get an instance of an output component */ final public class OutputPinFactory { /** * Get an instance of the output component * * @param block block containing the component * @return the instance */ static public OutputPin getOutput(Block block) { if(block.getBlockData() instanceof Switch) { final Switch myswitch = (Switch) block.getBlockData(); if(myswitch.getMaterial().equals(Material.LEVER)) { return new ComponentLever(block); } else { return new ComponentButton(block); } } return null; } }
712
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
OutputPin.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/OutputPin.java
package com.github.catageek.ByteCart.IO; /** * Represents a writable component, storing a single bit */ public interface OutputPin { /** * write the bit * * @param bit true to write 1, false to write 0 */ public void write(boolean bit); }
253
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
InputFactory.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/InputFactory.java
package com.github.catageek.ByteCart.IO; import org.bukkit.block.Block; import org.bukkit.block.data.AnaloguePowerable; import org.bukkit.block.data.Powerable; /** * A factory for input pins */ final public class InputFactory { /** * Get an instance of the input component * * @param block block containing the component * @return the instance */ @SuppressWarnings("unchecked") static public <T> T getInput(Block block) { if(block.getBlockData() instanceof AnaloguePowerable) { return (T) new ComponentWire(block); } if(block.getBlockData() instanceof Powerable) { return (T) new ComponentLever(block); } return null; } }
667
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ComponentSign.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/ComponentSign.java
package com.github.catageek.ByteCart.IO; import org.bukkit.block.Block; import org.bukkit.block.BlockState; import com.github.catageek.ByteCart.ByteCart; /** * A sign */ public final class ComponentSign extends AbstractComponent { /** * @param block the block containing the component */ public ComponentSign(Block block) { super(block); } /** * Set a line of the sign * * @param line index of the line * @param s the text to write */ public void setLine(int line, String s) { final BlockState blockstate = this.getBlock().getState(); if (blockstate instanceof org.bukkit.block.Sign) { ((org.bukkit.block.Sign) blockstate).setLine(line, s); blockstate.update(); } } /** * Get a line of a sign * * @param line index of the line * @return the text */ public String getLine(int line) { final BlockState blockstate = this.getBlock().getState(); if (blockstate instanceof org.bukkit.block.Sign) return ((org.bukkit.block.Sign) blockstate).getLine(line); else { ByteCart.log.info("ByteCart: AddressSign cannot be built"); throw new IllegalArgumentException(); } } }
1,134
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ComponentWire.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/ComponentWire.java
package com.github.catageek.ByteCart.IO; import org.bukkit.block.Block; import org.bukkit.block.data.AnaloguePowerable; import com.github.catageek.ByteCartAPI.HAL.RegistryInput; /** * A Redstone wire */ class ComponentWire extends AbstractComponent implements InputPin, RegistryInput { /** * @param block the block containing the wire */ ComponentWire(Block block) { super(block); /* if(ByteCart.debug) ByteCart.log.info("ByteCart : adding Redstone wire at " + block.getLocation().toString()); */ } /* (non-Javadoc) * @see com.github.catageek.ByteCart.IO.InputPin#read() */ @Override public boolean read() { if(((AnaloguePowerable) this.getBlock().getBlockData()).getPower() != 0) { // if(ByteCart.debug) // ByteCart.log.info("Redstone wire on at (" + this.getBlock().getLocation().toString() + ")"); return true; } // if(ByteCart.debug) // ByteCart.log.info("Redstone wire off at (" + this.getBlock().getLocation().toString() + ")"); return false; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryInput#getBit(int) */ @Override public boolean getBit(int index) { final AnaloguePowerable wire = ((AnaloguePowerable) this.getBlock().getBlockData()); return (wire.getPower() & 1 << (length() - index)) != 0; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#getAmount() */ @Override public int getAmount() { return ((AnaloguePowerable) this.getBlock().getBlockData()).getPower(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#length() */ @Override public int length() { return 4; } }
1,624
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ComponentLever.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/ComponentLever.java
package com.github.catageek.ByteCart.IO; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; import org.bukkit.block.data.BlockData; import org.bukkit.block.data.Powerable; import org.bukkit.block.data.type.Switch; import org.bukkit.block.data.type.Switch.Face; import com.github.catageek.ByteCartAPI.HAL.RegistryInput; import com.github.catageek.ByteCartAPI.Util.MathUtil; /** * A lever */ class ComponentLever extends AbstractComponent implements OutputPin, InputPin, RegistryInput { /** * @param block the block containing the component */ ComponentLever(Block block) { super(block); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.IO.OutputPin#write(boolean) */ @Override public void write(boolean bit) { final Block block = this.getBlock(); final BlockData md = block.getBlockData(); if(md instanceof Switch) { Switch pw = (Switch) md; pw.setPowered(bit); block.setBlockData(pw); Face face = pw.getFace(); switch (face) { case CEILING: MathUtil.forceUpdate(block.getRelative(BlockFace.UP,2)); break; case WALL: MathUtil.forceUpdate(block.getRelative(pw.getFacing().getOppositeFace())); break; default: MathUtil.forceUpdate(block.getRelative(BlockFace.DOWN)); } } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.IO.InputPin#read() */ @Override public boolean read() { BlockData md = this.getBlock().getBlockData(); if(md instanceof Powerable) { return ((Powerable) md).isPowered(); } return false; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryInput#getBit(int) */ @Override public boolean getBit(int index) { return read(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#getAmount() */ @Override public int getAmount() { return (read() ? 15 : 0); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#length() */ @Override public int length() { return 4; } }
1,990
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
InputPin.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/InputPin.java
package com.github.catageek.ByteCart.IO; /** * Represents a readable component, giving 1 bit */ public interface InputPin { /** * Read the bit * * @return true if 1, false otherwise */ public boolean read(); }
223
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Component.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/IO/Component.java
package com.github.catageek.ByteCart.IO; import org.bukkit.block.Block; /** * Represents a component, i.e a lever, a button, etc. */ interface Component { /** * Get the block containing the component * * @return the block */ public Block getBlock(); }
267
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BookInputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/BookInputStream.java
package com.github.catageek.ByteCart.FileStorage; import java.io.ByteArrayInputStream; import org.bukkit.ChatColor; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.Util.Base64; /** * An input stream to read from book */ class BookInputStream extends ByteArrayInputStream { /** * @param book the book * @param binary set binary mode */ BookInputStream(BookMeta book, boolean binary) { super(readPagesAsBytes(book, binary)); } /** * @param outputstream the output stream from where we read data */ BookInputStream(ItemStackMetaOutputStream outputstream) { super(outputstream.getBuffer()); } public String getBuffer() { return new String(this.buf); } /** * Copy all pages of a book in a array of bytes * * @param book the book * @param binary binary mode * @return the array of bytes */ public static String readPages(BookMeta book, boolean binary) { String sb = getRawPages(book); if (binary) return new String(Base64.decodeFast(sb)); return sb; } /** * Copy all pages of a book in a array of bytes * * @param book the book * @param binary binary mode * @return the array of bytes */ private static byte[] readPagesAsBytes(BookMeta book, boolean binary) { String sb = getRawPages(book); if (binary) return Base64.decodeFast(sb); return sb.getBytes(); } private static String getRawPages(BookMeta book) { int len = book.getPageCount() * BookOutputStream.PAGESIZE; StringBuilder sb = new StringBuilder(len); for (int i = 1; i <= book.getPageCount(); ++i) { sb.append(ChatColor.stripColor(book.getPage(i))); } sb.trimToSize(); return sb.toString(); } }
1,682
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BookProperties.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/BookProperties.java
package com.github.catageek.ByteCart.FileStorage; import java.io.Closeable; import java.io.Flushable; import java.io.IOException; import java.io.OutputStream; import java.util.Properties; import com.github.catageek.ByteCart.ByteCart; /** * A property file with a book as container */ public final class BookProperties implements Closeable, Flushable { private final Properties Properties = new Properties(); private final Conf PageNumber; private final BCFile file; private boolean isClosed = false; private OutputStream os = null; /** * The page names */ public enum Conf { NETWORK("Network"), BILLING("Billing"), ACCESS("Access"), PROTECTION("Protection"), HISTORY("History"); private final String name; Conf(String name) { this.name = name; } } /** * @param file the file * @param page the page */ public BookProperties(BCFile file, Conf page) { super(); this.file = file; try { Properties.load(file.getInputStream()); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } PageNumber = page; } /** * Set a property * * @param key the key * @param value the value * @throws IOException */ public void setProperty(String key, String value) throws IOException { if (ByteCart.debug) ByteCart.log.info("ByteCart: BookProperties : setting key " + key + " to " + value); Properties.setProperty(key, value); } /** * Save the content of the property buffer to the book * * @throws IOException */ private void save() throws IOException { file.clear(); os = file.getOutputStream(); Properties.store(os, PageNumber.name); } /** * Removes a property * * @param key the key to remove * @throws IOException */ public void clearProperty(String key) throws IOException { if (ByteCart.debug) ByteCart.log.info("ByteCart: BookProperties : clearing key " + key); Properties.remove(key); } /** * Get the property value * * @param key the property key * @return the value */ public String getString(String key) { return Properties.getProperty(key); } /** * Get the property value or a default value * * @param key the property key * @param defaultvalue the default value * @return the value, or the default value */ public String getString(String key, String defaultvalue) { return Properties.getProperty(key, defaultvalue); } /** * Get a property value as an integer or a default value * * @param key the property key * @param defaultvalue the default value * @return the value */ public int getInt(String key, int defaultvalue) { if (ByteCart.debug) ByteCart.log.info("ByteCart: property string : "+ Properties.getProperty(key, ""+defaultvalue)); return Integer.parseInt(Properties.getProperty(key, ""+defaultvalue)); } /* (non-Javadoc) * @see java.io.Flushable#flush() */ @Override public void flush() throws IOException { if(isClosed) throw new IOException("Property file has been already closed"); save(); } /* (non-Javadoc) * @see java.io.Closeable#close() */ @Override public void close() throws IOException { if(isClosed) throw new IOException("Property file has been already closed"); isClosed = true; } /** * Get the container that contains this property file * * @return the container file */ public final BCFile getFile() { return file; } }
3,407
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/package-info.java
/** * */ /** * Package with classes to mount books as file */ package com.github.catageek.ByteCart.FileStorage;
116
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ItemStackOutputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/ItemStackOutputStream.java
package com.github.catageek.ByteCart.FileStorage; import java.io.OutputStream; import org.bukkit.inventory.ItemStack; /** * An output stream associated with an ItemStack */ abstract class ItemStackOutputStream extends OutputStream { ItemStackOutputStream(org.bukkit.inventory.ItemStack itemStack) { super(); ItemStack = itemStack; } private final ItemStack ItemStack; final ItemStack getItemStack() { return ItemStack; } }
443
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BookOutputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/BookOutputStream.java
package com.github.catageek.ByteCart.FileStorage; import java.io.ByteArrayOutputStream; import java.io.IOException; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.ByteCart; /** * An output stream to write in book */ class BookOutputStream extends ByteArrayOutputStream { static final int PAGESIZE = 255; private static final int MAXPAGE = 50; static final int MAXSIZE = MAXPAGE * PAGESIZE; private final BookMeta book; private boolean isClosed = false; BookOutputStream(BookMeta book) { super(book.getPageCount() * PAGESIZE); this.book = book; } /* (non-Javadoc) * @see java.io.ByteArrayOutputStream#write(byte[], int, int) */ @Override public void write (byte[] bytes, int off, int len) { // this.reset(); // if(ByteCart.debug) // ByteCart.log.info("ByteCart : empty data cache buffer"); super.write(bytes, off, len); } /* (non-Javadoc) * @see java.io.OutputStream#write(byte[]) */ @Override public void write(byte[] bytes) throws IOException { if (isClosed) throw new IOException("Book has been already closed"); this.write(bytes, 0, bytes.length); } /** * Get the content as a byte array * * @return the buffer */ protected byte[] getBuffer() { return this.toByteArray(); } /* (non-Javadoc) * @see java.io.OutputStream#flush() */ @Override public void flush() throws IOException { if (isClosed) throw new IOException("Book has been already closed"); if (this.size() == 0) return; StringBuilder sb = new StringBuilder(getEncodedString()); int len= sb.length(); int i, j = 1; // number of pages to write int count = 1 + (len - 1) / PAGESIZE; // Throw if too many pages are needed if (count > MAXPAGE) { if (ByteCart.debug) ByteCart.log.info(count + " pages are needed, maximum is " + MAXPAGE); throw new IOException(); } String[] strings = new String[count]; // loop for full pages count -= 1; for (i = 0; i < count; i++) { strings[i] = sb.substring(i * PAGESIZE, j * PAGESIZE); j++; } // last page strings[count] = sb.substring(i * PAGESIZE); this.book.setPages(strings); if(ByteCart.debug) ByteCart.log.info("ByteCart : Flushing " + len + " bytes of data to meta"); } /** * Get the content as a string * * @return the content of the book */ protected String getEncodedString() { return this.toString(); } /* (non-Javadoc) * @see java.io.ByteArrayOutputStream#close() */ @Override public void close() throws IOException { if (isClosed) throw new IOException("Book has been already closed"); isClosed = true; } /** * Get the book * * @return the book */ final BookMeta getBook() { return book; } }
2,738
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BookFile.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/BookFile.java
package com.github.catageek.ByteCart.FileStorage; import java.io.IOException; import java.io.OutputStream; import java.util.ArrayList; import java.util.List; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.FileStorage.BookInputStream;; /** * A class handling a file stored in a book */ public final class BookFile implements BCFile { static final int MAXSIZE = BookOutputStream.MAXSIZE; private static final String prefix = ByteCart.myPlugin.getConfig().getString("author"); private BookMeta book; private final ItemStack stack; private ItemStackMetaOutputStream outputstream; private boolean isClosed = false; private final Inventory container; private final boolean binarymode; private final int slot; /** * @param inventory the inventory * @param index the slot index * @param binary true to set binary mode * @param name the suffix of the author name, or null */ private BookFile(Inventory inventory, int index, boolean binary) { this.binarymode = binary; this.container = inventory; this.slot = index; this.stack = inventory.getItem(index); this.book = (BookMeta) stack.getItemMeta(); } static public BookFile getFrom(Inventory inventory, int index, boolean binary, String name) { ItemStack mystack = inventory.getItem(index); if (mystack == null || ! mystack.getType().equals(Material.WRITTEN_BOOK)) { return null; } BookMeta mybook = null; if (mystack.hasItemMeta()) { mybook = (BookMeta) mystack.getItemMeta(); } else { return null; } if ( ! mybook.hasAuthor() || ! mybook.getAuthor().startsWith(prefix)) { return null; } if (name != null && ! mybook.getAuthor().equals(prefix + "." + name)) { return null; } BookFile bookfile = new BookFile(inventory, index, binary); // fix corrupted books in MC 1.8 try { @SuppressWarnings("unused") List<String> test = mybook.getPages(); } catch(NullPointerException e) { inventory.clear(index); bookfile = create(inventory, index, binary, name); } return bookfile; } private static boolean isBookFile(String name, BookMeta mybook) { return mybook.getAuthor().equals(prefix + "." + name); } static public BookFile create(Inventory inventory, int index, boolean binary, String name) { ItemStack mystack = inventory.getItem(index); return BookFile.create(inventory, mystack, index, binary, name); } static private BookFile create(Inventory inventory, ItemStack mystack, int index, boolean binary, String name) { if (mystack == null || ! mystack.getType().equals(Material.WRITTEN_BOOK)) { mystack = new ItemStack(Material.WRITTEN_BOOK); } final BookMeta mybook = (BookMeta) Bukkit.getServer().getItemFactory().getItemMeta(Material.WRITTEN_BOOK); if (name != null) { final String myauthor = prefix + "." + name; mybook.setAuthor(myauthor); } else { mybook.setAuthor(prefix); } mystack.setItemMeta(mybook); inventory.setItem(index, mystack); return new BookFile(inventory, index, binary); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#getCapacity() */ @Override public int getCapacity() { return MAXSIZE; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#clear() */ @Override public void clear() { if (outputstream != null) this.outputstream.getBook().setPages(new ArrayList<String>()); else book.setPages(new ArrayList<String>()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#isEmpty() */ @Override public boolean isEmpty() { if (outputstream != null) return ! outputstream.getBook().hasPages() || outputstream.getBook().getPage(1).length() == 0; else return ! book.hasPages() || book.getPage(1).length() == 0; } @Override public String getPages() { return BookInputStream.readPages(book, binarymode); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#getOutputStream() */ @Override public OutputStream getOutputStream() throws IOException { if (isClosed) throw new IOException("Book File has already been closed"); if (outputstream != null) return outputstream; BookOutputStream bookoutputstream = binarymode ? new Base64BookOutputStream(book) : new BookOutputStream(book); return outputstream = new ItemStackMetaOutputStream(stack, bookoutputstream); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#getInputStream() */ @Override public BookInputStream getInputStream() throws IOException { if (isClosed) throw new IOException("Book File has already been closed"); if (outputstream != null && outputstream.getBuffer().length != 0){ return new BookInputStream(outputstream); } return new BookInputStream(book, binarymode); } /* (non-Javadoc) * @see java.io.Flushable#flush() */ @Override public void flush() throws IOException { if (outputstream != null){ if (isClosed) throw new IOException("Book File has already been closed"); outputstream.flush(); book = outputstream.getBook(); } else { stack.setItemMeta(book); this.getContainer().setItem(slot, stack); } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#getContainer() */ @Override public Inventory getContainer() { return container; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#setDescription(java.lang.String) */ @Override public void setDescription(String s) throws IOException { if (isClosed) throw new IOException("Book File has already been closed"); if (outputstream != null) { outputstream.getBook().setTitle(s); book = outputstream.getBook(); } else book.setTitle(s); } /** * Tell if a slot of an inventory contains a file in a book * * @param inventory the inventory * @param index the slot number * @param suffix suffix of the author name * @return true if the slot contains a file and the author field begins with author configuration parameter */ static boolean isBookFile(Inventory inventory, int index, String suffix) { return isBookFile(inventory.getItem(index), suffix); } /** * Tell if an ItemStack contains a file in a book * * @param stack the ItemStack * @param suffix suffix of the author name * @return true if the slot contains a file and the author field begins with author configuration parameter */ public static boolean isBookFile(ItemStack stack, String suffix) { if (stack != null && stack.getType().equals(Material.WRITTEN_BOOK) && stack.hasItemMeta()) return isBookFile(suffix, (BookMeta) stack.getItemMeta()) || suffix == null; return false; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BCFile#getDescription() */ @Override public String getDescription() throws IOException { if (isClosed) throw new IOException("Book File has already been closed"); if (outputstream != null) { return outputstream.getBook().getTitle(); } else return book.getTitle(); } public static ItemStack sign(ItemStack mystack, String name) { if (mystack == null || mystack.getType() != Material.WRITABLE_BOOK) { return null; } mystack.setType(Material.WRITTEN_BOOK); final BookMeta mybook = (BookMeta) mystack.getItemMeta(); if (name != null) mybook.setAuthor(BookFile.prefix + "." + "name"); else mybook.setAuthor(BookFile.prefix); return mystack; } }
7,617
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
InventoryFile.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/InventoryFile.java
package com.github.catageek.ByteCart.FileStorage; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import org.bukkit.inventory.Inventory; public final class InventoryFile implements BCFile { private final Inventory inventory; private final boolean binarymode; private final String name; private InventoryOutputStream outputstream; private String title = ""; public InventoryFile(Inventory inventory, boolean binary, String name) { this.inventory = inventory; this.binarymode = binary; this.name = name; } @Override public void flush() throws IOException { if (outputstream != null) outputstream.flush(); } @Override public int getCapacity() { return BookFile.MAXSIZE * inventory.getSize(); } @Override public void clear() { this.inventory.clear(); } @Override public boolean isEmpty() { return this.inventory.firstEmpty() == 0; } @Override public OutputStream getOutputStream() throws IOException { if (outputstream != null) return outputstream; return outputstream = new InventoryOutputStream(inventory, binarymode, title, name); } @Override public InputStream getInputStream() throws IOException { if (outputstream != null && outputstream.toByteArray().length != 0){ return new InventoryInputStream(outputstream); } return new InventoryInputStream(inventory, binarymode, name); } public static boolean isInventoryFile(Inventory inv, String name) { return InventoryInputStream.isInventoryInputStream(inv, name); } @Override public Inventory getContainer() { return inventory; } @Override public void setDescription(String s) throws IOException { this.title = s; } @Override public String getDescription() throws IOException { return this.title; } @Override public String getPages() { return InventoryInputStream.readPages(inventory, name, binarymode); } }
1,897
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
InventoryInputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/InventoryInputStream.java
package com.github.catageek.ByteCart.FileStorage; import java.io.ByteArrayInputStream; import java.io.IOException; import org.bukkit.Material; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.Util.Base64; final class InventoryInputStream extends ByteArrayInputStream { /** * @param book the book * @param binary set binary mode */ InventoryInputStream(Inventory inv, boolean binary, String name) { super(readPagesAsBytes(inv, name, binary)); } public InventoryInputStream(InventoryOutputStream outputstream) { super(outputstream.toByteArray()); } public static String readPages(Inventory inv, String name, boolean binary) { String sb = getRawContent(inv, name); if (binary) return new String(Base64.decodeFast(sb)); return sb; } static boolean isInventoryInputStream(Inventory inv, String name) { for (int i = 0; i < inv.getSize(); ++i) { if (BookFile.isBookFile(inv, i, name)) { return true; } } return false; }; /** * Get the underlying inputstream * * @param slot the slot where the book is * @return the book inputstream * @throws IOException */ private static BookInputStream getBookInputStream(Inventory inventory, int slot, String name) { BookFile book = BookFile.getFrom(inventory, slot, false, name); if (book == null) { return null; } BookInputStream ret = null; try { ret = book.getInputStream(); } catch (IOException e) { e.printStackTrace(); } return ret; } private static byte[] readPagesAsBytes(Inventory inv, String name, boolean binary) { String sb = getRawContent(inv, name); if (binary) return Base64.decodeFast(sb); return sb.getBytes(); } private static String getRawContent(Inventory inv, String name) { int bookcount = inv.all(Material.WRITTEN_BOOK).size(); int len = bookcount * BookFile.MAXSIZE; StringBuilder sb = new StringBuilder(len); for (int i = 0; i < bookcount; ++i) { final BookInputStream bookInputStream = getBookInputStream(inv, i, name); if (bookInputStream != null) { sb.append(bookInputStream.getBuffer()); } } sb.trimToSize(); return sb.toString(); } }
2,160
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
FileStorageTest.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/FileStorageTest.java
package com.github.catageek.ByteCart.FileStorage; import java.io.IOException; import java.io.OutputStream; import java.util.Random; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; public final class FileStorageTest { private final Inventory inventory; private final static Random rng = new Random(); private final static String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; public FileStorageTest(Inventory inv) { this.inventory = inv; } static String generateString(int length) { char[] text = new char[length]; for (int i = 0; i < length; i++) { text[i] = characters.charAt(rng.nextInt(characters.length())); } return new String(text); } public void runTest() { run(1); run(512); run(32767); run(128000); int len = inventory.getSize() * BookFile.MAXSIZE; run(len); run(len + 1); } public void run(int len) { inventory.clear(); ByteCart.log.info("isInventoryFile() ? empty inventory : " + (InventoryFile.isInventoryFile(inventory, "test") ? "NOK" : "OK")); InventoryFile file1 = new InventoryFile(inventory, false, "test"); ByteCart.log.info("isEmpty() ? empty inventory : " + (file1.isEmpty() ? "OK" : "NOK")); OutputStream outputstream = null; String string1 = generateString(len); try { outputstream = file1.getOutputStream(); outputstream.write(string1.getBytes()); outputstream.flush(); outputstream.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); return; } ByteCart.log.info("isEmpty() ? test inventory : " + (file1.isEmpty() ? "NOK" : "OK")); ByteCart.log.info("isInventoryFile() ? test inventory : " + (InventoryFile.isInventoryFile(inventory, "test") ? "OK" : "NOK")); ByteCart.log.info("isInventoryFile() ? wrong name : " + (InventoryFile.isInventoryFile(inventory, "othertest") ? "NOK" : "OK")); InventoryFile file2 = new InventoryFile(inventory, false, "test"); ByteCart.log.info("isEmpty() ? test2 inventory : " + (file2.isEmpty() ? "NOK" : "OK")); String string2 = file2.getPages(); for (int i = 0; i < len; i += BookFile.MAXSIZE) { ByteCart.log.info("Test of string of " + len + " bytes : " + i + " " + (string2.regionMatches(i, string1, i, Math.min(BookFile.MAXSIZE, len - i * BookFile.MAXSIZE)) ? "OK" : "NOK")); } } }
2,345
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ItemStackMetaOutputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/ItemStackMetaOutputStream.java
package com.github.catageek.ByteCart.FileStorage; import java.io.IOException; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.ByteCart; /** * An outputstream for a book in an ItemStack. Write operations in the book update the ItemStack object */ final class ItemStackMetaOutputStream extends ItemStackOutputStream { private final BookOutputStream OutputStream; private boolean isClosed = false; /** * @param stack the stack containing the book * @param outputstream an output stream for the book */ ItemStackMetaOutputStream(ItemStack stack, BookOutputStream outputstream) { super(stack); OutputStream = outputstream; } /* (non-Javadoc) * @see java.io.OutputStream#write(byte[], int, int) */ @Override public void write(byte[] cbuf, int off, int len) throws IOException { if (isClosed) throw new IOException("ItemStack has been already closed"); OutputStream.write(cbuf, off, len); } /* (non-Javadoc) * @see java.io.OutputStream#flush() */ @Override public void flush() throws IOException { if (isClosed) throw new IOException("ItemStack has been already closed"); OutputStream.flush(); getItemStack().setItemMeta(OutputStream.getBook()); if(ByteCart.debug) ByteCart.log.info("ByteCart : Flushing meta to itemstack"); } /* (non-Javadoc) * @see java.io.OutputStream#close() */ @Override public void close() throws IOException { if (isClosed) throw new IOException("ItemStack has been already closed"); if(ByteCart.debug) ByteCart.log.info("ByteCart : Closing itemstack"); OutputStream.close(); isClosed = true; } /* (non-Javadoc) * @see java.io.OutputStream#write(int) */ @Override public void write(int b) throws IOException { if (isClosed) throw new IOException("ItemStack has been already closed"); OutputStream.write(b); } /** * Get the current buffer * * @return the buffer */ final byte[] getBuffer() { return OutputStream.getBuffer(); } /** * Get the book * * @return the book */ final BookMeta getBook() { return OutputStream.getBook(); } }
2,154
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BCFile.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/BCFile.java
package com.github.catageek.ByteCart.FileStorage; import java.io.Flushable; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import org.bukkit.inventory.Inventory; /** * Represents a file with various operations */ public interface BCFile extends Flushable { /** * Get the capacity, in bytes, of the file * * @return the capacity */ int getCapacity(); /** * clear the file content * */ void clear(); /** * Tell if a file is empty * * @return true if empty */ boolean isEmpty(); /** * Get an output stream for this file * * @return the stream * @throws IOException */ OutputStream getOutputStream() throws IOException; /** * Get an input stream * * @return the stream * @throws IOException */ InputStream getInputStream() throws IOException; /** * Get the inventory containing this file * * @return the inventory */ Inventory getContainer(); /** * Set a title to this file * * @param s the title to set * @throws IOException */ void setDescription(String s) throws IOException; /** * Get the title for this file * * @return the title * @throws IOException */ String getDescription() throws IOException; /** * Get all the pages in one string * @return all the pages */ String getPages(); }
1,339
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
InventoryOutputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/InventoryOutputStream.java
package com.github.catageek.ByteCart.FileStorage; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.OutputStream; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.Util.Base64; class InventoryOutputStream extends ByteArrayOutputStream { private final Inventory inventory; private final boolean binary; private final String name; private final String title; InventoryOutputStream(Inventory inventory, boolean binary, String title, String name) { this.inventory = inventory; this.binary = binary; this.name = name; this.title = title; } /** * Get the content as a string * * @return the content of the book */ private String getEncodedString() { return binary ? Base64.encodeToString(buf, false) : this.toString(); } /** * Get the underlying OutputStream * * @param slot the slot where the book is * @return the book outputstream * @throws IOException */ private void writeData(byte[] data, int slot) throws IOException { final BookFile book = BookFile.create(inventory, slot, false, name); book.setDescription(this.title); OutputStream outputstream = book.getOutputStream(); outputstream.write(data); outputstream.flush(); } /* (non-Javadoc) * @see java.io.OutputStream#flush() */ @Override public void flush() throws IOException { if (this.size() == 0) return; StringBuilder sb = new StringBuilder(getEncodedString()); int len= sb.length(); int i, j = 1; // number of books to write int count = 1 + (len - 1) / BookFile.MAXSIZE; // Throw if too many books are needed if (count > this.inventory.getSize()) { if (ByteCart.debug) ByteCart.log.info(count + " books are needed, maximum is " + this.inventory.getSize()); throw new IOException(); } String mystring; // loop for full books count -= 1; for (i = 0; i < count; i++) { mystring = sb.substring(i * BookFile.MAXSIZE, j * BookFile.MAXSIZE); writeData(mystring.getBytes(), i); j++; } // last page mystring = sb.substring(i * BookFile.MAXSIZE); writeData(mystring.getBytes(), i++); // Clear last slots for(; i < this.inventory.getSize(); i++) { this.inventory.clear(i); } if(ByteCart.debug) ByteCart.log.info("ByteCart : Flushing " + len + " bytes of data to books"); } }
2,381
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Base64BookOutputStream.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/FileStorage/Base64BookOutputStream.java
package com.github.catageek.ByteCart.FileStorage; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.Util.Base64; /** * Base64 encoder/decoder for BookOutPutStream */ final class Base64BookOutputStream extends BookOutputStream { public Base64BookOutputStream(BookMeta book) { super(book); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BookOutputStream#getEncodedString() */ @Override protected String getEncodedString() { return Base64.encodeToString(buf, false); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.FileStorage.BookOutputStream#getBuffer() */ @Override protected byte[] getBuffer() { return Base64.encodeToByte(buf, false); } }
731
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Wanderer/package-info.java
/** * */ /** * Package to mark a cart as a wanderer that will trigger events */ package com.github.catageek.ByteCart.Wanderer;
131
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
WandererContent.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Wanderer/WandererContent.java
package com.github.catageek.ByteCart.Wanderer; import java.util.Calendar; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Stack; import java.util.UUID; import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.Routing.BCCounter; import com.github.catageek.ByteCart.Routing.Metric; import com.github.catageek.ByteCartAPI.Util.DirectionRegistry; import com.github.catageek.ByteCartAPI.Wanderer.InventoryContent; import com.github.catageek.ByteCartAPI.Wanderer.RoutingTable; import com.github.catageek.ByteCartAPI.Wanderer.Wanderer; public class WandererContent implements InventoryContent { /** * */ private static final long serialVersionUID = -9068486630910859194L; private transient Inventory inventory = null; private UUID player; private BCCounter counter; private long creationtime = Calendar.getInstance().getTimeInMillis(); private int lastrouterid; private Stack<Integer> Start; private Stack<Integer> End; //internal variable used by updaters private int Current = -2; private long expirationtime; protected Map<Integer, Metric> tablemap = new HashMap<Integer, Metric>(); public WandererContent(Inventory inv, Wanderer.Level level, int region, Player player) { this.Region = region; this.Level = level; this.inventory = inv; this.player = player.getUniqueId(); counter = new BCCounter(); setStart(new Stack<Integer>()); setEnd(new Stack<Integer>()); } /** * Set the counter instance * * @param counter the counter instance to set */ final void setCounter(BCCounter counter) { this.counter = counter; } private Wanderer.Level Level; private int Region; /** * Set the level of the updater * * @param level the level to store */ final void setLevel(Wanderer.Level level) { Level = level; } /** * Set the region of the updater * * @param region the region to set */ final void setRegion(int region) { Region = region; } /** * Get the level of the updater * * @return the level */ @Override public Wanderer.Level getLevel() { return Level; } /** * Get the region of the updater * * @return the region */ @Override public int getRegion() { return Region; } /** * Get the ring id where the updater thinks it is in * * @return the ring id */ @Override public int getCurrent() { return Current; } /** * Set the ring id where the updater thinks it is in * * @param current the ring id */ @Override public void setCurrent(int current) { Current = current; } /** * @return the counter */ @Override public BCCounter getCounter() { return counter; } /** * @return the inventory */ @Override public Inventory getInventory() { return inventory; } /** * @param inventory the inventory to set */ public void setInventory(Inventory inventory) { this.inventory = inventory; } public long getCreationtime() { return creationtime; } /** * @param creationtime the creationtime to set */ @SuppressWarnings("unused") private void setCreationtime(long creationtime) { this.creationtime = creationtime; } /** * @return the player */ @Override public Player getPlayer() { return Bukkit.getPlayer(player); } /** * Get the id previously stored * * @return the id */ public final int getLastrouterid() { return lastrouterid; } /** * Store an id in the updater book * * @param lastrouterid the id to store */ public final void setLastrouterid(int lastrouterid) { this.lastrouterid = lastrouterid; } /** * @return the start */ @Override public Stack<Integer> getStart() { return Start; } /** * @return the end */ @Override public Stack<Integer> getEnd() { return End; } /** * @param start the start to set */ private void setStart(Stack<Integer> start) { Start = start; } /** * @param end the end to set */ private void setEnd(Stack<Integer> end) { End = end; } public long getExpirationTime() { return expirationtime; } /** * Set the expiration time * * @param lastupdate the lastupdate to set */ @Override public void setExpirationTime(long lastupdate) { this.expirationtime = lastupdate; } /** * Insert an entry in the IGP packet * * @param number the ring id * @param metric the metric value */ @Override public void setRoute(int number, int metric) { tablemap.put(number, new Metric(metric)); if(ByteCart.debug) ByteCart.log.info("ByteCart : setting metric of ring " + number + " to " + metric); } /** * Get the metric value of a ring of the IGP exchange packet * * @param entry the ring id * @return the metric */ @Override public int getMetric(int entry) { return tablemap.get(entry).value(); } /** * Get the ring that has the minimum metric in the IGP packet * * @param routingTable the routing table * @param from the direction to exclude from the search * @return the ring id, or -1 */ @Override public int getMinDistanceRing(RoutingTable routingTable, DirectionRegistry from) { Iterator<Integer> it = routingTable.getOrderedRouteNumbers(); if (! it.hasNext()) return -1; //skip ring 0 it.next(); int route; int min = 10000, ret = -1; // big value while (it.hasNext()) { route = it.next(); if (routingTable.getDirection(route) != from.getBlockFace()) { if (! this.hasRouteTo(route)) { if(ByteCart.debug) ByteCart.log.info("ByteCart : found ring " + route + " was never visited"); return route; } else { if (getMetric(route) < min) { min = getMetric(route); ret = route; } } } } if(ByteCart.debug) ByteCart.log.info("ByteCart : minimum found ring " + ret + " with " + min); return ret; } /** * Tells if the IGP packet has data on a ring * * @param ring the ring id * @return true if there is data on this ring */ @Override public boolean hasRouteTo(int ring) { return tablemap.containsKey(ring); } }
6,138
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BCWandererManager.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Wanderer/BCWandererManager.java
package com.github.catageek.ByteCart.Wanderer; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.Calendar; import java.util.Date; import java.util.HashMap; import java.util.Map; import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.FileStorage.InventoryFile; import com.github.catageek.ByteCart.Util.LogUtil; import com.github.catageek.ByteCartAPI.Wanderer.InventoryContent; import com.github.catageek.ByteCartAPI.Wanderer.Wanderer.Level; import com.github.catageek.ByteCartAPI.Wanderer.Wanderer.Scope; import com.github.catageek.ByteCartAPI.Wanderer.WandererFactory; import com.github.catageek.ByteCartAPI.Wanderer.WandererManager; public class BCWandererManager implements WandererManager { private static final Map<String, WandererFactory> map = new HashMap<String, WandererFactory>(); /** * Register a wanderer type * * @param wanderer the wanderer class implementing the wanderer * @param type the name that will reference this type of wanderer */ @Override public boolean register(WandererFactory factory, String type) { if (map.containsKey(type)) return false; map.put(type, factory); return true; } /** * Get a wanderer * * @param bc the sign that request the wanderer * @param inv the inventory where to extract the wanderercontent from * @return the wanderer * @throws ClassNotFoundException * @throws IOException */ @Override public WandererFactory getFactory(Inventory inv) throws ClassNotFoundException, IOException { if (isWanderer(inv) && getWandererContent(inv) != null) return map.get(getType(inv)); return null; } public WandererFactory getFactory(String type) { if (isRegistered(type)) return map.get(type); return null; } @Override public boolean isWanderer(Inventory inv, Scope scope) { return isWanderer(inv, scope, null, null); } @Override public boolean isWanderer(Inventory inv, Level level, String type) { return isWanderer(inv, level.scope, level.type, type); } @Override public boolean isWanderer(Inventory inv, String type) { return isWanderer(inv, null, null, type); } private boolean isWanderer(Inventory inv, Scope scope, String suffix, String type) { if (! isWanderer(inv)) return false; ItemStack stack = inv.getItem(0); if (stack != null && stack.getType().equals(Material.WRITTEN_BOOK) && stack.hasItemMeta()) { final BookMeta book = (BookMeta) stack.getItemMeta(); final String booktitle = book.getTitle(); final String dot = "\\."; final StringBuilder match = new StringBuilder(); match.append("^"); final String alphanums = "[a-zA-Z]{1,}"; if (type != null) match.append(type).append(dot); else match.append(alphanums).append(dot); if (scope != null) match.append(scope.name).append(dot); else match.append(alphanums).append(dot); if (suffix != null) match.append(suffix).append(dot); match.append(".*"); if (InventoryFile.isInventoryFile(inv, type) && booktitle.matches(match.toString())) { return true; } } return false; } public boolean isWanderer(Inventory inv) { String prefix = getType(inv); if (prefix != null) return isRegistered(prefix); return false; } private String getType(Inventory inv) { ItemStack stack = inv.getItem(0); String prefix = null; if (stack != null && stack.getType().equals(Material.WRITTEN_BOOK) && stack.hasItemMeta()) { BookMeta book = (BookMeta) stack.getItemMeta(); String booktitle = book.getTitle(); int index = booktitle.indexOf("."); if (index > 0) prefix = booktitle.substring(0, index); } return prefix; } /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.WandererManager#isWandererType(java.lang.String) */ @Override public boolean isRegistered(String type) { return map.containsKey(type); } @Override public WandererContent getWandererContent(Inventory inv) throws IOException, ClassNotFoundException { WandererContent rte = null; InventoryFile file = null; if (InventoryFile.isInventoryFile(inv, null)) { file = new InventoryFile(inv, true, null); } if (file == null) { throw new IOException("No book found"); } if (! file.isEmpty()) { ObjectInputStream ois = new ObjectInputStream(file.getInputStream()); rte = (WandererContent) ois.readObject(); } rte.setInventory(inv); return rte; } /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.WandererManager#saveContent(com.github.catageek.ByteCartAPI.Wanderer.InventoryContent, java.lang.String, com.github.catageek.ByteCartAPI.Wanderer.Wanderer.Level) */ @Override public void saveContent(InventoryContent rte, String suffix, Level level) throws ClassNotFoundException, IOException { Inventory inv = rte.getInventory(); // delete content if expired long creation = rte.getCreationtime(); long expiration = rte.getExpirationTime(); if (creation != expiration && Calendar.getInstance().getTimeInMillis() > expiration) { LogUtil.sendSuccess(rte.getPlayer(), "ByteCart : " + suffix + " created " + (new Date(rte.getCreationtime())).toString() + " expired"); WandererFactory factory = getFactory(inv); if (factory != null) { factory.destroyWanderer(inv); } return; } InventoryFile file = createWanderer(inv, rte.getRegion(), rte.getLevel(), rte.getPlayer(), suffix, level); ObjectOutputStream oos = new ObjectOutputStream(file.getOutputStream()); oos.writeObject(rte); try { oos.flush(); } catch (IOException e) { getFactory(inv).destroyWanderer(inv); ByteCart.log.info("Bytecart: I/O error (maximum capacity reached), updater deleted"); } } private static InventoryFile createWanderer(Inventory inv, int region, Level level, Player player , String name, Level type) throws IOException { InventoryFile file = new InventoryFile(inv, true, name); String dot = "."; StringBuilder match = new StringBuilder(); match.append(name).append(dot).append(level.scope.name); match.append(dot).append(type.type).append(dot); file.setDescription(match.toString()); return file; } @Override public void unregister(String name) { map.remove(name); } }
6,433
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
SuperRegistry.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/HAL/SuperRegistry.java
package com.github.catageek.ByteCart.HAL; import com.github.catageek.ByteCartAPI.HAL.Registry; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; import com.github.catageek.ByteCartAPI.HAL.RegistryInput; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; // This class represents 2 registries merged /** * A registry grouping 2 registries * * @param <T> A type extending Registry */ public class SuperRegistry<T extends Registry> implements RegistryBoth { // Registry1 est le registre de poids fort private final Registry Registry1, Registry2; /** * @param reg1 The left part, i.e MSB side * @param reg2 The right part, i.e LSB side */ public SuperRegistry(T reg1, T reg2) { this.Registry1 = reg1; this.Registry2 = reg2; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryOutput#setBit(int, boolean) */ @Override public void setBit(int index, boolean value) { if (index < this.Registry1.length()) ( (RegistryOutput) this.Registry1).setBit(index, value); else ((RegistryOutput) this.Registry2).setBit(index-this.Registry1.length(), value); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryInput#getBit(int) */ @Override public boolean getBit(int index) { if (index < this.Registry1.length()) return ((RegistryInput) this.Registry1).getBit(index); return ((RegistryInput) this.Registry2).getBit(index-this.Registry1.length()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#length() */ @Override public int length() { return this.Registry1.length() + this.Registry2.length(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#getAmount() */ @Override public int getAmount() { return (this.Registry1.getAmount() << this.Registry2.length()) + this.Registry2.getAmount(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryOutput#setAmount(int) */ @Override public void setAmount(int amount) { ((RegistryOutput) this.Registry1).setAmount(amount >> (this.Registry2.length()) % ( 1 << this.Registry1.length())); ((RegistryOutput) this.Registry2).setAmount(amount & (( 1 << this.Registry2.length() ) - 1)); } }
2,214
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/HAL/package-info.java
/** */ /** * Abstraction layer for various ingame components. * * Basic element of this layer are pins representing a single component. * * Registries are composite elements grouping a set of pins. */ package com.github.catageek.ByteCart.HAL;
252
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractIC.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/HAL/AbstractIC.java
package com.github.catageek.ByteCart.HAL; import java.util.Map; import java.util.WeakHashMap; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; import org.bukkit.block.Sign; import org.bukkit.block.data.BlockData; import org.bukkit.block.data.Directional; import org.bukkit.block.data.Rotatable; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.IO.ComponentSign; import com.github.catageek.ByteCartAPI.HAL.IC; import com.github.catageek.ByteCartAPI.HAL.RegistryInput; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; import com.github.catageek.ByteCartAPI.Util.MathUtil; // All ICs must inherit from this class /** * An abstract class implementing common methods for all ICs */ abstract public class AbstractIC implements IC { final private Block Block; final private org.bukkit.Location Location; private static final Map<String,Boolean> icCache = new WeakHashMap<String, Boolean>(); private static org.bukkit.Location emptyLocation = new org.bukkit.Location(null, 0, 0, 0); /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getName() */ @Override abstract public String getName(); /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getFriendlyName() */ @Override public String getFriendlyName() { return ((Sign) this.getBlock().getState()).getLine(2); } private RegistryInput[] input = new RegistryInput[9]; private int input_args = 0; private RegistryOutput[] output = new RegistryOutput[6]; private int output_args = 0; public AbstractIC(Block block) { this.Block = block; if (block != null) { this.Location = block.getLocation(); } else { this.Location = new org.bukkit.Location(null, 0, 0, 0); } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#addInputRegistry(com.github.catageek.ByteCart.HAL.RegistryInput) */ @Override public final void addInputRegistry(RegistryInput reg) { this.input[this.input_args++] = reg; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#addOutputRegistry(com.github.catageek.ByteCart.HAL.RegistryOutput) */ @Override public final void addOutputRegistry(RegistryOutput reg) { this.output[this.output_args++] = reg; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getInput(int) */ @Override public final RegistryInput getInput(int index) { return input[index]; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getOutput(int) */ @Override public final RegistryOutput getOutput(int index) { return output[index]; } static public final void removeFromCache(Block block) { icCache.remove(block.getLocation(emptyLocation).toString()); } // This function checks if we have a ByteCart sign at this location static public final boolean checkEligibility(Block b){ if(!(b.getState() instanceof Sign)) { return false; } Boolean ret; String s; if ((ret = icCache.get(s = b.getLocation(emptyLocation).toString())) != null) return ret; String line_content = ((Sign) b.getState()).getLine(1); if (ByteCart.myPlugin.getConfig().getBoolean("FixBroken18", false)) { if (ret = AbstractIC.checkLooseEligibility(line_content)) { (new ComponentSign(b)).setLine(1,"["+line_content+"]"); } else { ret = AbstractIC.checkEligibility(line_content); } } else { ret = AbstractIC.checkEligibility(line_content); } icCache.put(s, ret); return ret; } static public final boolean checkEligibility(String s){ if(! (s.matches("^\\[BC[0-9]{4,4}\\]$"))) { return false; } return true; } static private final boolean checkLooseEligibility(String s){ if(! (s.matches("^BC[0-9]{4,4}$"))) { return false; } return true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getCardinal() */ @Override public final BlockFace getCardinal() { final BlockData blockdata = this.getBlock().getState().getBlockData(); if(blockdata instanceof Directional) { return ((Directional) blockdata).getFacing().getOppositeFace(); } if(blockdata instanceof Rotatable) { BlockFace f = ((Rotatable) blockdata).getRotation().getOppositeFace(); f = MathUtil.straightUp(f); if (f == BlockFace.UP) { ByteCart.log.severe("ByteCart: Tilted sign found at " + this.getLocation() + ". Please straight it up in the axis of the track"); return null; } return f; } return null; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getBlock() */ @Override public final Block getBlock() { return Block; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getBuildPermission() */ @Override public final String getBuildPermission() { return "bytecart." + getName(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getTriggertax() */ @Override public final int getTriggertax() { return ByteCart.myPlugin.getConfig().getInt("usetax." + this.getName()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getBuildtax() */ @Override public final int getBuildtax() { return ByteCart.myPlugin.getConfig().getInt("buildtax." + this.getName()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.IC#getLocation() */ @Override public org.bukkit.Location getLocation() { return Location; } }
5,352
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
PinRegistry.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/HAL/PinRegistry.java
package com.github.catageek.ByteCart.HAL; import java.util.Arrays; import java.util.List; import java.util.ListIterator; import com.github.catageek.ByteCart.IO.InputPin; import com.github.catageek.ByteCart.IO.OutputPin; import com.github.catageek.ByteCartAPI.HAL.Registry; import com.github.catageek.ByteCartAPI.HAL.RegistryInput; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; /** * A registry implementation * * @param <T> InputPin or OutputPin type */ public class PinRegistry<T> implements RegistryInput, RegistryOutput, Registry { final private List<T> PinArray; /** * @param pins an array of pins */ public PinRegistry(T[] pins) { this.PinArray = Arrays.asList(pins); /* if(ByteCart.debug) ByteCart.log.info("ByteCart : creating PinRegistry with" + this.length() + "pin(s)"); */ } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#length() */ @Override public int length() { return PinArray.size(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#getAmount() */ @Override public int getAmount() { int amount = 0; int i = 1; for (ListIterator<T> it = this.PinArray.listIterator(this.length()); it.hasPrevious(); i = i << 1) { if(it.previous() != null) { it.next(); if (((InputPin) it.previous()).read()) { amount += i; } } } return amount; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryOutput#setBit(int, boolean) */ @Override public void setBit(int index, boolean value) { ((OutputPin) this.PinArray.get(index)).write(value); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryOutput#setAmount(int) */ @Override public void setAmount(int amount) { int i = amount; for (ListIterator<T> it = this.PinArray.listIterator(this.length()); it.hasPrevious(); i = i >> 1) { if(it.previous() != null) { it.next(); if ( (i & 1) !=0 ) { ((OutputPin) it.previous()).write(true); } else { ((OutputPin) it.previous()).write(false); } } } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryInput#getBit(int) */ @Override public boolean getBit(int index) { return ((InputPin) this.PinArray.get(index)).read(); } }
2,320
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
SubRegistry.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/HAL/SubRegistry.java
package com.github.catageek.ByteCart.HAL; import com.github.catageek.ByteCartAPI.HAL.Registry; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; import com.github.catageek.ByteCartAPI.HAL.RegistryInput; import com.github.catageek.ByteCartAPI.HAL.RegistryOutput; /** * A restricted view of a registry * * @param <T> A type implementing Registry */ public class SubRegistry <T extends Registry> implements RegistryBoth { private final Registry Registry; private final int Length; private final int First; /** * @param reg the original registry * @param length the length of the restricted view * @param first the index of the first bit of the restricted view */ public SubRegistry(T reg, int length, int first) { this.Registry = reg; this.Length = length; this.First = first; /* if(ByteCart.debug) ByteCart.log.info("ByteCart : creating SubRegistry " + reg.length() + " -> " + length + " bits beginning at index "+ first); */ } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#length() */ @Override public int length() { return this.Length; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.Registry#getAmount() */ @Override public int getAmount() { return (this.Registry.getAmount() >> (this.Registry.length() - (this.First + this.length())) & ( 1 << this.length()) - 1); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryOutput#setBit(int, boolean) */ @Override public void setBit(int index, boolean value) { ((RegistryOutput) this.Registry).setBit(index + this.First, value); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryInput#getBit(int) */ @Override public boolean getBit(int index) { return ((RegistryInput) this.Registry).getBit(index+ this.First); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.HAL.RegistryOutput#setAmount(int) */ @Override public void setAmount(int amount) { ((RegistryOutput) this.Registry).setAmount(this.Registry.getAmount() - this.getAmount() + ((amount % (1 << this.length())) << (this.Registry.length() - (this.First + this.length())))); } }
2,149
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Storage/package-info.java
/** * */ /** * A package providing some persistent in-memory storage */ package com.github.catageek.ByteCart.Storage;
122
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ExternalizableTreeMap.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Storage/ExternalizableTreeMap.java
package com.github.catageek.ByteCart.Storage; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import java.util.Comparator; import java.util.Iterator; import java.util.Map; import java.util.SortedMap; import java.util.TreeMap; /** * A treemap that can be saved (i.e externalized) as a binary stream * * @param <K> the key type of the map * @param <V> the value type of the map */ public final class ExternalizableTreeMap<K extends Externalizable, V extends Externalizable> extends TreeMap<K, V> implements Externalizable { private static final long serialVersionUID = 1074583778619610579L; public ExternalizableTreeMap() { super(); } public ExternalizableTreeMap(Comparator<? super K> comparator) { super(comparator); } public ExternalizableTreeMap(Map<? extends K, ? extends V> m) { super(m); } public ExternalizableTreeMap(SortedMap<K, ? extends V> arg0) { super(arg0); } /* (non-Javadoc) * @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @SuppressWarnings("unchecked") @Override public void readExternal(ObjectInput s) throws IOException, ClassNotFoundException { // Read in size int size = s.readShort(); for (int i = 0; i < size; i++) { K key = (K) s.readObject(); V value = (V) s.readObject(); this.put(key, value); } } /* (non-Javadoc) * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput) */ @Override public void writeExternal(ObjectOutput s) throws IOException { // Write out size (number of Mappings) s.writeShort(size()); // Write out keys and values (alternating) for (Iterator<Map.Entry<K,V>> i = entrySet().iterator(); i.hasNext(); ) { Map.Entry<K,V> e = i.next(); s.writeObject(e.getKey()); s.writeObject(e.getValue()); } } }
1,830
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ExpirableMap.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Storage/ExpirableMap.java
package com.github.catageek.ByteCart.Storage; import java.util.Collections; import java.util.HashMap; import java.util.Map; import com.github.catageek.ByteCart.ThreadManagement.Expirable; /** * A map in which elements are deleted after a timeout * * @param <K> the type of keys of the set * @param <T> the type of values of the set */ public final class ExpirableMap<K, T> extends Expirable<K> { private final Map<K, T> Map = Collections.synchronizedMap(new HashMap<K,T>()); /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#Expirable(long, boolean, String) */ public ExpirableMap(long duration, boolean isSync, String name) { super(duration, isSync, name); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#expire(java.lang.Object[]) */ @SuppressWarnings("unchecked") @Override public void expire(Object... objects) { ((Map<K,?>)objects[1]).remove(objects[0]); } /** * Add an element to the map * * @param key key of the element * @param value value of the element * @param reset must be set to true to reset the timeout to initial value, false otherwise * @return true if the element was added */ private boolean put(K key, T value, boolean reset) { // if(ByteCart.debug) // ByteCart.log.info("ByteCart: create ephemeral key (" + key +") in " + this.getName() + " for " + this.getDuration() + " ticks"); if (reset) this.reset(key, key, Map); return (Map.put(key, value) == null); } /** * Add an element to the map * * @param key key of the element * @param value value of the element * @return true if the element was added */ public boolean put(K key, T value) { return this.put(key, value, true); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#reset(java.lang.Object, java.lang.Object[]) */ @Override public void reset(K key, Object...objects) { super.reset(key, key, Map); } /** * Remove an element from the map * * @param key the key of the element */ public final void remove(K key) { Map.remove(key); this.cancel(key); } /** * Get the value of the element having a specific key * * @param key the key of the element * @return the value */ public T get(K key) { return Map.get(key); } /** * Tell if the map contains an element * * @param key the element to check * @return true if the element is in the map */ public boolean contains(K key) { return Map.containsKey(key); } /** * Remove all the elements of the map * */ public void clear() { Map.clear(); } /** * Tell if the map is empty * * @return true if the map is empty */ public boolean isEmpty() { return Map.isEmpty(); } }
2,756
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
PartitionedHashSet.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Storage/PartitionedHashSet.java
package com.github.catageek.ByteCart.Storage; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import com.github.catageek.ByteCartAPI.Storage.Partitionable; /** * A set containing powers of 2 of an integer * * @param <E> A partitionable type */ public class PartitionedHashSet<E extends Partitionable> extends HashSet<E> { /** * */ private static final long serialVersionUID = 7798172721619367114L; public PartitionedHashSet() { } public PartitionedHashSet(Collection<? extends E> c) { super(c); } public PartitionedHashSet(int initialCapacity) { super(initialCapacity); } public PartitionedHashSet(int initialCapacity, float loadFactor) { super(initialCapacity, loadFactor); } /** * Get the addition of values from the set * * @return the value */ public final int getPartitionedValue() { int ret = 0; Iterator<E> it = this.iterator(); while (it.hasNext()) { ret |= it.next().getAmount(); } return ret; } }
1,001
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ExpirableSet.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Storage/ExpirableSet.java
package com.github.catageek.ByteCart.Storage; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import com.github.catageek.ByteCart.ThreadManagement.Expirable; /** * A set in which elements are deleted after a timeout * * @param <K> the type of elements of the set */ public final class ExpirableSet<K> extends Expirable<K> { private final Set<K> Set = Collections.synchronizedSet(new HashSet<K>()); /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#Expirable(long, boolean, String) */ public ExpirableSet(long duration, boolean isSync, String name) { super(duration, isSync, name); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#expire(java.lang.Object[]) */ @SuppressWarnings("unchecked") @Override public void expire(Object... objects) { ((Set<K>)objects[1]).remove(objects[0]); } /** * Add an element to the set * * @param key the element to add * @return true if the element was added */ public boolean add(K key) { // if(ByteCart.debug) // ByteCart.log.info("ByteCart: create ephemeral key (" + key +") in " + this.getName() + " for " + this.getDuration() + " ticks"); this.reset(key, key, Set); return Set.add(key); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#reset(java.lang.Object, java.lang.Object[]) */ @Override public void reset(K key, Object...objects) { super.reset(key, key, Set); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.ThreadManagement.Expirable#reset(long, java.lang.Object, java.lang.Object[]) */ @Override public void reset(long duration, K key, Object...objects) { super.reset(duration, key, key, Set); } /** * Remove the element from the set * * @param key the element to remove */ public final void remove(K key) { Set.remove(key); this.cancel(key); } /** * Tells if the set contains an element * * @param key the element to check * @return true if the element is in the set */ public boolean contains(K key) { return Set.contains(key); } /** * Tells if the set is empty * * @return true if the set is empty */ public boolean isEmpty() { return Set.isEmpty(); } /** * Empty the set */ public void clear() { Iterator<K> it = Set.iterator(); while (it.hasNext()) this.cancel(it.next()); Set.clear(); } public Iterator<K> getIterator() { return Set.iterator(); } }
2,509
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
IsTrainManager.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Storage/IsTrainManager.java
package com.github.catageek.ByteCart.Storage; import org.bukkit.Location; /** * A map that contain the train bit for each component * * The train bit set to true means that a train is currently using the component */ public final class IsTrainManager { private ExpirableMap<Location, Boolean> IsTrain = new ExpirableMap<Location, Boolean>(14, false, "isTrain"); /** * Get the map * * @return the map */ public ExpirableMap<Location, Boolean> getMap() { return IsTrain; } }
500
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Returnable.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/Returnable.java
package com.github.catageek.ByteCart.AddressLayer; /** * Represent a return address */ interface Returnable extends AddressRouted { }
138
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AddressString.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/AddressString.java
package com.github.catageek.ByteCart.AddressLayer; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCartAPI.AddressLayer.Address; import com.github.catageek.ByteCartAPI.AddressLayer.Resolver; import com.github.catageek.ByteCartAPI.HAL.VirtualRegistry; /** * This class represents a canonical address like xx.xx.xx */ public class AddressString extends AbstractAddress implements Address { /** * String used as internal storage */ private String String; // address as displayed private final static Resolver resolver; static { resolver = ByteCart.myPlugin.getResolver(); } /** * Creates the address * * @param s the string containing the address or a name to resolve to an address */ public AddressString(String s, boolean resolve) { if (isAddress(s)) { this.String = s; return; } if (isResolvableName(s)) { if (resolve) { this.String = resolver.resolve(s); } else { this.String = s; } return; } this.String = null; this.isValid = false; } /** * Static method to check the format of an address * * A resolvable name will return true * * This method does not check if the address fields are in a valid range * * @param s the string containing the address to check * @return true if the address is in the valid format or a resolvable name */ static public boolean isResolvableAddressOrName(String s) { if((s.matches("([0-9]{1,4}\\.){2,2}[0-9]{1,3}")) || isResolvableName(s)) { return true; } return false; } /** * Static method to check the format of an address * * This method does not check if the address fields are in a valid range * * @param s the string containing the address to check * @return true if the address is in the valid format */ static private boolean isAddress(String s) { if(! (s.matches("([0-9]{1,4}\\.){2,2}[0-9]{1,3}"))) { return false; } return true; } /** * Static method to check if a name resolution gives a valid address * * @param s the string containing the name to check * @return true if the resolution gives an address */ static private boolean isResolvableName(String name) { if (resolver != null) { String a = resolver.resolve(name); if (a != null && AddressString.isAddress(a)) return true; } return false; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getRegion() */ @Override public VirtualRegistry getRegion() { VirtualRegistry ret; (ret = new VirtualRegistry(Offsets.REGION.getLength())).setAmount(this.getField(0)); return ret; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getTrack() */ @Override public VirtualRegistry getTrack() { VirtualRegistry ret; (ret = new VirtualRegistry(Offsets.TRACK.getLength())).setAmount(this.getField(1)); return ret; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getStation() */ @Override public VirtualRegistry getStation() { VirtualRegistry ret; (ret = new VirtualRegistry(Offsets.STATION.getLength())).setAmount(this.getField(2)); return ret; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isTrain() */ @Override public boolean isTrain() { throw new UnsupportedOperationException(); } /** * Return a field by index * * @param index a number between 0 and 2 * @return the number contained in the field */ private int getField(int index) { if (this.String == null) throw new IllegalStateException("Address is not valid."); String[] st = this.String.split("\\."); return Integer.parseInt(st[ index ].trim()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#setRegion(int) */ @Override public void setRegion(int region) { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#setTrack(int) */ @Override public void setTrack(int track) { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#setStation(int) */ @Override public void setStation(int station) { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#setIsTrain(boolean) */ @Override public void setIsTrain(boolean isTrain) { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#toString() */ @Override public java.lang.String toString() { if (this.String != null) return this.String; return ""; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#setAddress(java.lang.String) */ @Override public boolean setAddress(java.lang.String s) { if (isResolvableAddressOrName(s)) { this.String = s; this.isValid = true; } else { this.String = null; this.isValid = false; } return this.isValid; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AbstractAddress#UpdateAddress() */ @Override protected boolean UpdateAddress() { finalizeAddress(); return true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#remove() */ @Override public void remove() { this.String = null; this.isValid = false; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isReturnable() */ @Override public boolean isReturnable() { return false; } }
5,610
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/package-info.java
/** * Address layer package */ /** * This package provides classes to manage destination and return address on various support: Book, sign, string. */ package com.github.catageek.ByteCart.AddressLayer;
205
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AddressSign.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/AddressSign.java
package com.github.catageek.ByteCart.AddressLayer; import org.bukkit.block.Block; import com.github.catageek.ByteCart.IO.AbstractComponent; import com.github.catageek.ByteCart.IO.ComponentSign; import com.github.catageek.ByteCartAPI.AddressLayer.Address; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; /** * Implements an address using a line of a sign as support */ final class AddressSign extends AbstractComponent implements Address { /** * String used as internal storage */ private final AddressString Address; /** * Creates the address * * @param block the sign block containing the address * @param ligne the line number containing the address */ AddressSign(Block block, int ligne) { super(block); this.Address = new AddressString((new ComponentSign(block)).getLine(ligne), false); /* if(ByteCart.debug) ByteCart.log.info("ByteCart: creating AddressSign line #" + ligne + " at " + block.getLocation().toString()); */ } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getRegion() */ @Override public final RegistryBoth getRegion() { return Address.getRegion(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getTrack() */ @Override public final RegistryBoth getTrack() { return Address.getTrack(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getStation() */ @Override public final RegistryBoth getStation() { return Address.getStation(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String) */ @Override public final boolean setAddress(String s) { this.Address.setAddress(s); return true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String, java.lang.String) */ @Override public boolean setAddress(String s, String name) { (new ComponentSign(this.getBlock())).setLine(2, name); return setAddress(s); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isTrain() */ @Override public boolean isTrain() { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setTrain(boolean) */ @Override public boolean setTrain(boolean istrain) { throw new UnsupportedOperationException(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#finalizeAddress() */ @Override public final void finalizeAddress() { (new ComponentSign(this.getBlock())).setLine(3, this.Address.toString()); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isValid() */ @Override public boolean isValid() { return this.Address.isValid; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#remove() */ @Override public void remove() { this.Address.remove(); (new ComponentSign(this.getBlock())).setLine(3, ""); } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override final public String toString() { return Address.toString(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isReturnable() */ @Override public boolean isReturnable() { return false; } }
3,322
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AddressRouted.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/AddressRouted.java
package com.github.catageek.ByteCart.AddressLayer; import com.github.catageek.ByteCartAPI.AddressLayer.Address; /** * Represents an address currently routed */ public interface AddressRouted extends Address { /** * Get the TTL (time-to-live) associated with the address * * * @return the TTL */ public int getTTL(); /** * Set the TTL * * {@link Address#finalizeAddress()} should be called later to actually set the TTL * * @param i the value to set */ public void updateTTL(int i); /** * Initialize TTL to its default value * * {@link Address#finalizeAddress()} should be called later to actually initialize the TTL * */ public void initializeTTL(); }
701
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AddressBook.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/AddressBook.java
package com.github.catageek.ByteCart.AddressLayer; import org.bukkit.entity.Player; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCartAPI.AddressLayer.Address; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; /** * A class implementing an address using a book as support */ final class AddressBook implements AddressRouted { /** * Parameters name used in the book */ public enum Parameter { DESTINATION("net.dst.addr"), RETURN("net.src.addr"), TTL("net.ttl"), TRAIN("net.train"); private final String name; Parameter(String s) { name = s; } /** * @return the name */ public String getName() { return name; } } /** * The ticket used as support for the address */ private final Ticket ticket; /** * The type of the address */ private final Parameter parameter; /** * Creates an address using a ticket and a parameter * * @param ticket the ticket where to store the address * @param parameter the type of address to store */ AddressBook(Ticket ticket, Parameter parameter) { this.ticket = ticket; this.parameter = parameter; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getRegion() */ @Override public RegistryBoth getRegion() { return getAddress().getRegion(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getTrack() */ @Override public RegistryBoth getTrack() { return getAddress().getTrack(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getStation() */ @Override public RegistryBoth getStation() { return getAddress().getStation(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isTrain() */ @Override public boolean isTrain() { return ticket.getString(Parameter.TRAIN, "false").equalsIgnoreCase("true"); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String) */ @Override public boolean setAddress(String s) { return setAddress(s, null); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String, java.lang.String) */ @Override public boolean setAddress(String value, String stationname) { boolean ret = this.ticket.setEntry(parameter, value); if (parameter.equals(Parameter.DESTINATION)) { if(ByteCart.debug) ByteCart.log.info("ByteCart : set title"); ticket.appendTitle(stationname, value); } return ret; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setTrain(boolean) */ @Override public boolean setTrain(boolean istrain) { if (istrain) return ticket.setEntry(Parameter.TRAIN, "true"); ticket.remove(Parameter.TRAIN); return true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isValid() */ @Override public boolean isValid() { return getAddress().isValid(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AddressRouted#getTTL() */ @Override public int getTTL() { return ticket.getInt(Parameter.TTL, ByteCart.myPlugin.getConfig().getInt("TTL.value")); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AddressRouted#updateTTL(int) */ @Override public void updateTTL(int i) { ticket.setEntry(Parameter.TTL, ""+i); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AddressRouted#initializeTTL() */ @Override public void initializeTTL() { this.ticket.resetValue(Parameter.TTL, ByteCart.myPlugin.getConfig().getString("TTL.value")); } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return getAddress().toString(); } /** * Read the address from the ticket * * @return the address */ private Address getAddress() { String defaultaddr = ByteCart.myPlugin.getConfig().getString("EmptyCartsDefaultRoute", "0.0.0"); return new AddressString(ticket.getString(parameter, defaultaddr),true); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#remove() */ @Override public void remove() { ticket.remove(parameter); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isReturnable() */ @Override public boolean isReturnable() { return ticket.getString(Parameter.RETURN) != null; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#finalizeAddress() */ @SuppressWarnings("deprecation") @Override public void finalizeAddress() { ticket.close(); if (ticket.getTicketHolder() instanceof Player) { if(ByteCart.debug) ByteCart.log.info("ByteCart : update player inventory"); ((Player) ticket.getTicketHolder()).updateInventory(); } } }
4,813
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AddressFactory.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/AddressFactory.java
package com.github.catageek.ByteCart.AddressLayer; import org.bukkit.block.Block; import org.bukkit.entity.Player; import org.bukkit.entity.Vehicle; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.AddressLayer.AddressBook.Parameter; import com.github.catageek.ByteCart.FileStorage.BookFile; import com.github.catageek.ByteCart.FileStorage.BookProperties.Conf; import com.github.catageek.ByteCart.Signs.BC7010; import com.github.catageek.ByteCart.Signs.BC7011; import com.github.catageek.ByteCartAPI.AddressLayer.Address; /** * Factory to create address using various supports */ public class AddressFactory { /** * Get an address with a ticket as support * * @param inv the inventory containing the ticket * @return the address or null if there is no ticket */ @SuppressWarnings("unchecked") public final static <T extends Address> T getAddress(Inventory inv){ int slot = Ticket.getTicketslot(inv); if (slot != -1) { BookFile bookfile = BookFile.getFrom(inv, slot, false, "ticket"); if (bookfile != null) return (T) new AddressBook(new Ticket(bookfile, Conf.NETWORK), Parameter.DESTINATION); } return null; } /** * Creates a ticket with default address * * @param inv the inventory containing the ticket * @return the address */ @SuppressWarnings("unchecked") public final static <T extends Address> T getDefaultTicket(Inventory inv){ String destination; if (inv.getHolder() instanceof Player) { destination = ByteCart.myPlugin.getConfig().getString("PlayersNoTicketDefaultRoute", "0.0.0"); if ((new BC7010(null,(Player)inv.getHolder())).setAddress(destination,"No ticket found !")) { return (T) new AddressBook(new Ticket(BookFile.getFrom(inv, Ticket.getTicketslot(inv), false, "ticket"), Conf.NETWORK), Parameter.DESTINATION); } } else if (inv.getHolder() instanceof Vehicle) { destination = ByteCart.myPlugin.getConfig().getString("EmptyCartsDefaultRoute", "0.0.0"); if ((new BC7011(null,(Vehicle)inv.getHolder())).setAddress(destination,"No ticket found !")) { return (T) new AddressBook(new Ticket(BookFile.getFrom(inv, Ticket.getTicketslot(inv), false, "ticket"), Conf.NETWORK), Parameter.DESTINATION); } } return null; } /** * Creates an address with a sign as support * * @param b the sign block * @param line the line number * @return the address */ public final static Address getAddress(Block b, int line){ return new AddressSign(b, line); } /** * Creates an address with a string as internal support * * The address is resolved. * * @param s the address in the form aa.bb.cc * @return the address */ public final static Address getAddress(String s){ return new AddressString(s, true); } /** * Creates an address with a string as internal support * * The address is not resolved. * * @param s the address in the form aa.bb.cc * @return the address */ final static Address getUnresolvedAddress(String s){ return new AddressString(s, false); } }
3,078
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ReturnAddressBook.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/ReturnAddressBook.java
package com.github.catageek.ByteCart.AddressLayer; import com.github.catageek.ByteCart.AddressLayer.AddressBook.Parameter; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; /** * A class implementing a return address in a book */ final class ReturnAddressBook implements Returnable { /** * Creates a return address from a ticket of a certain type * * @param ticket the ticket to use as support * @param parameter the type of the address */ ReturnAddressBook(Ticket ticket, Parameter parameter) { this.address = new AddressBook(ticket, parameter); } /** * The book address that this class will proxify */ private final AddressBook address; /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getRegion() */ @Override public RegistryBoth getRegion() { return address.getRegion(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getTrack() */ @Override public RegistryBoth getTrack() { return address.getTrack(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#getStation() */ @Override public RegistryBoth getStation() { return address.getStation(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isTrain() */ @Override public boolean isTrain() { return address.isTrain(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String) */ @Override public boolean setAddress(String s) { return address.setAddress(s); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String, java.lang.String) */ @Override public boolean setAddress(String s, String name) { return address.setAddress(s); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setTrain(boolean) */ @Override public boolean setTrain(boolean istrain) { return address.setTrain(istrain); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isValid() */ @Override public boolean isValid() { return address.isValid(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#remove() */ @Override public void remove() { address.remove(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AddressRouted#getTTL() */ @Override public int getTTL() { return address.getTTL(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AddressRouted#updateTTL(int) */ @Override public void updateTTL(int i) { address.updateTTL(i); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.AddressRouted#initializeTTL() */ @Override public void initializeTTL() { address.initializeTTL(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#isReturnable() */ @Override public boolean isReturnable() { return address.isReturnable(); } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return address.toString(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#finalizeAddress() */ @Override public void finalizeAddress() { address.finalizeAddress(); } }
3,294
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractAddress.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/AbstractAddress.java
package com.github.catageek.ByteCart.AddressLayer; import com.github.catageek.ByteCartAPI.ByteCartAPI; import com.github.catageek.ByteCartAPI.AddressLayer.Address; /** * Abstract class implementing basic operations on address * * All address subclass must extend this class */ abstract class AbstractAddress implements Address { /** * A flag to tell to the world if the address should be considered as valid or not */ protected boolean isValid = true; @Override public final boolean isValid() { return isValid; } /** * Length (in bits) for various fields of address * * position is deprecated */ protected enum Offsets { // length (default : 6), pos (default : 0) REGION(ByteCartAPI.MAXRINGLOG, 0), TRACK(ByteCartAPI.MAXRINGLOG, 0), STATION(ByteCartAPI.MAXSTATIONLOG, 0); private final int Length, Offset; private Offsets() { Length = 6; Offset = 0; } private Offsets(int length, int offset) { Length = length; Offset = offset; } /** * @return the length */ public int getLength() { return Length; } /** * @return the offset */ public int getOffset() { return Offset; } } /** * Copy the fields of the address object * * @param a the source address to copy * @return true if the address was copied */ private boolean setAddress(Address a) { this.setStation(a.getStation().getAmount()); this.setIsTrain(a.isTrain()); this.setTrack(a.getTrack().getAmount()); this.setRegion(a.getRegion().getAmount()); return this.UpdateAddress(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(com.github.catageek.ByteCart.AddressLayer.Address, java.lang.String) */ @Override public boolean setAddress(String a, String name) { return this.setAddress(a); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setAddress(java.lang.String) */ @Override public boolean setAddress(String s) { return setAddress(AddressFactory.getUnresolvedAddress(s)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#setTrain(boolean) */ @Override public final boolean setTrain(boolean istrain) { this.setIsTrain(istrain); return this.UpdateAddress(); } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public String toString() { return "" + this.getRegion().getAmount() + "." + this.getTrack().getAmount() + "." + (this.getStation().getAmount()); } /** * flush the address to its support * * * @return always true */ protected boolean UpdateAddress() { finalizeAddress(); return true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.AddressLayer.Address#finalizeAddress() */ @Override public void finalizeAddress() { } /** * Set the region field * * * @param region the region number to set */ abstract protected void setRegion(int region); /** * Set the ring field * * * @param track the ring number to set */ abstract protected void setTrack(int track); /** * Set the station field * * * @param station the station number to set */ abstract protected void setStation(int station); /** * Set the train flag * * * @param isTrain true if the flag must be set */ abstract protected void setIsTrain(boolean isTrain); }
3,358
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
ReturnAddressFactory.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/ReturnAddressFactory.java
package com.github.catageek.ByteCart.AddressLayer; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.AddressLayer.AddressBook.Parameter; import com.github.catageek.ByteCart.FileStorage.BookFile; import com.github.catageek.ByteCart.FileStorage.BookProperties.Conf; import com.github.catageek.ByteCartAPI.AddressLayer.Address; /** * Factory class to create a return address from various supports */ public final class ReturnAddressFactory { /** * Creates a return address from a ticket * * @param inv the inventory containing the ticket * @return the return address */ @SuppressWarnings("unchecked") public final static <T extends Address> T getAddress(Inventory inv){ int slot; if ((slot = Ticket.getTicketslot(inv)) != -1) return (T) new ReturnAddressBook(new Ticket(BookFile.getFrom(inv, slot, false, "ticket"), Conf.NETWORK), Parameter.RETURN); return null; } }
918
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
TicketFactory.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/TicketFactory.java
package com.github.catageek.ByteCart.AddressLayer; import org.bukkit.ChatColor; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.InventoryHolder; import com.github.catageek.ByteCart.ByteCart; /** * Factory to create or get a ticket */ public final class TicketFactory { /** * Put a ticket in a player's inventory if necessary * * @param player the player * @param forcereuse must be true to force the reuse of existing ticket */ @SuppressWarnings("deprecation") public static final void getOrCreateTicket(Player player, boolean forcereuse) { int slot; Inventory inv = player.getInventory(); if (forcereuse || ByteCart.myPlugin.getConfig().getBoolean("reusetickets", true)) { // if storage cart or we must reuse a existing ticket // check if a ticket exists and return // otherwise continue slot = Ticket.getTicketslot(inv); if (slot != -1) return; } // get a slot containing an emtpy book (or nothing) if ((slot = Ticket.getEmptyOrBookAndQuillSlot(player)) == -1) return; if (inv.getItem(slot) == null && ByteCart.myPlugin.getConfig().getBoolean("mustProvideBooks")) { String msg = "No empty book in your inventory, you must provide one."; player.sendMessage(ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED + msg); return; } Ticket.createTicket(inv, slot); player.updateInventory(); } /** * Put a ticket in an inventory, if necessary. The inventory is not updated. * * @param inv the inventory where to put the ticket */ public static final void getOrCreateTicket(Inventory inv) { int slot; // if storage cart or we must reuse a existing ticket // check if a ticket exists and return // otherwise continue slot = Ticket.getTicketslot(inv); if (slot != -1) return; Ticket.createTicket(inv, Ticket.searchSlot(inv)); } /** * Remove a ticket from an inventory * * @param inv */ @SuppressWarnings("deprecation") public static final void removeTickets(Inventory inv) { int slot; while ((slot = Ticket.getTicketslot(inv)) != -1) { inv.clear(slot); } InventoryHolder holder; if ((holder = inv.getHolder()) instanceof Player) ((Player) holder).updateInventory(); } }
2,256
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Ticket.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/AddressLayer/Ticket.java
package com.github.catageek.ByteCart.AddressLayer; import java.io.IOException; import java.util.ListIterator; import org.bukkit.ChatColor; import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.InventoryHolder; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.PlayerInventory; import org.bukkit.inventory.meta.BookMeta; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.AddressLayer.AddressBook.Parameter; import com.github.catageek.ByteCart.FileStorage.BookFile; import com.github.catageek.ByteCart.FileStorage.BookProperties; import com.github.catageek.ByteCart.FileStorage.BookProperties.Conf; /** * Implement a ticket */ final class Ticket { /** * Internal storage of the ticket */ private final BookProperties properties; /** * Create a ticket using a book at a specific page * * @param bookfile the book FS to use * @param network the name of the page */ Ticket(BookFile bookfile, Conf network) { properties = new BookProperties(bookfile, network); } /** * Get a slot containing a ticket * * * @param inv The inventory to search in * @return a slot number, or -1 */ static int getTicketslot(Inventory inv) { if (inv.contains(Material.WRITTEN_BOOK)) { // priority given to book in hand if (inv instanceof PlayerInventory) { if (isTicket(((PlayerInventory) inv).getItemInMainHand())) { return ((PlayerInventory) inv).getHeldItemSlot(); } } ListIterator<ItemStack> it = inv.iterator(); while (it.hasNext()) { if (isTicket(it.next())) return it.previousIndex(); } } return -1; } /** * Tell if a stack is a ticket * * @param stack the stack to check * @return true if it is a ticket */ private final static boolean isTicket(ItemStack stack) { return BookFile.isBookFile(stack, "ticket"); } /** * Get a slot containing an empty book or nothing * * * @param inv The inventory to search in * @return a slot number, or -1 */ private static int getEmptyOrBookAndQuillSlot(Inventory inv) { ItemStack stack; if (ByteCart.myPlugin.getConfig().getBoolean("mustProvideBooks") && inv.contains(Material.WRITABLE_BOOK)) { // priority given to book in hand if (inv instanceof PlayerInventory) { if (isEmptyBook(stack = ((PlayerInventory) inv).getItemInMainHand())) { return ((PlayerInventory) inv).getHeldItemSlot(); } } ListIterator<? extends ItemStack> it = inv.iterator(); while (it.hasNext()) { stack = it.next(); if (isEmptyBook(stack)) { int slot = it.previousIndex(); // found a book return slot; } } } // no book found or user must provide one, return empty slot int slot = inv.firstEmpty(); if (slot != -1) { return slot; } return -1; } /** * Get a slot containing an empty book or nothing * * * @param player The player having the inventory to search in * @return a slot number, or -1 */ static int getEmptyOrBookAndQuillSlot(Player player) { int slot; if ((slot = getEmptyOrBookAndQuillSlot(player.getInventory())) == -1) { String msg = "Error: No space in inventory."; player.sendMessage(ChatColor.DARK_GREEN+"[Bytecart] " + ChatColor.RED + msg); } return slot; } /** * Get a slot containing an empty book or nothing * * * @param inv The inventory to search in * @return a slot number, or -1 */ static int searchSlot(Inventory inv) { int slot; // get a slot containing an emtpy book (or nothing) slot = Ticket.getEmptyOrBookAndQuillSlot(inv); if (slot != -1) { if (inv.getItem(slot) == null && ByteCart.myPlugin.getConfig().getBoolean("mustProvideBooks") && ByteCart.myPlugin.getConfig().getBoolean("usebooks")) { return -1; } return slot; } return -1; } /** * Initialize a ticket in a inventory * * @param inv the inventory where to put the ticket * @param slot the slot number where to put the ticket */ static void createTicket(Inventory inv, int slot) { if (slot == -1) return; // swap with an existing book if needed int existingticket = Ticket.getTicketslot(inv); if (existingticket != -1 && existingticket != slot) { inv.setItem(slot, inv.getItem(existingticket)); slot = existingticket; } try { BookFile bookfile = BookFile.create(inv, slot, false, "ticket"); bookfile.setDescription(ByteCart.myPlugin.getConfig().getString("title")); bookfile.flush(); } catch (IOException e) { e.printStackTrace(); } } /** * Tell if a book_and_quill is empty * * @param stack the ItemStack to check * @return true if it is an empty book_and_quill */ private static boolean isEmptyBook(ItemStack stack) { BookMeta book; if (stack != null && stack.getType().equals(Material.WRITABLE_BOOK)) { if (stack.hasItemMeta()) { if ((book = (BookMeta)stack.getItemMeta()).hasPages() && (book.getPage(1).isEmpty())) return true; } else { return true; } } return false; } /** * Get the holder of the ticket * * @return the holder */ InventoryHolder getTicketHolder() { return properties.getFile().getContainer().getHolder(); } /** * Set a parameter value in the ticket * * <p>{@link Ticket#close()} must be called to actually perform the operation</p> * * @param parameter parameter to set * @param value value to set * @return true */ final boolean setEntry(Parameter parameter, String value) { try { properties.setProperty(parameter.getName(), value); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return true; } /** * Return the value of a parameter or a default value * * @param parameter the parameter to return * @param defaultvalue the default value * @return a string containing the parameter value, or the default value */ final String getString(Parameter parameter, String defaultvalue) { return properties.getString(parameter.getName(), defaultvalue); } /** * Return the value of a parameter * * @param parameter the parameter to return * @return a string containing the parameter value */ final String getString(Parameter parameter) { return properties.getString(parameter.getName()); } /** * Append a name and a string to the title * * <p>{@link Ticket#close()} must be called to actually perform the operation</p> * * <p>The appended value is " name (string)"</p> * * @param name * @param s */ void appendTitle(String name, String s) { StringBuilder build = new StringBuilder(ByteCart.myPlugin.getConfig().getString("title")); if (name != null) build.append(" ").append(name); build.append(" ").append(s); try { properties.getFile().setDescription(build.toString()); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * Get a parameter value as an integer or a default value * * @param parameter the parameter to get * @param defaultvalue the default value * @return the parameter value */ final int getInt(Parameter parameter, int defaultvalue) { return properties.getInt(parameter.getName(), defaultvalue); } /** * Reset the parameter to default value * * <p>{@link Ticket#close()} must be called to actually perform the operation</p> * * @param parameter the parameter to set * @param defaultvalue the value to set */ void resetValue(Parameter parameter, String defaultvalue) { try { properties.setProperty(parameter.getName(), defaultvalue); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * Remove a parameter * * <p>{@link Ticket#close()} must be called to actually perform the operation</p> * * @param parameter parameter to remove */ void remove(Parameter parameter) { try { properties.clearProperty(parameter.getName()); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } /** * Write the parameters and close the ticket * */ void close() { try { properties.flush(); properties.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
8,321
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
AbstractRoutingTable.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/AbstractRoutingTable.java
package com.github.catageek.ByteCart.Routing; import java.util.Iterator; import java.util.Set; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCartAPI.Wanderer.RoutingTable; /** * An abstract class for routing tables */ abstract class AbstractRoutingTable implements RoutingTable { /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#isDirectlyConnected(int, org.bukkit.block.BlockFace) */ @Override public final boolean isDirectlyConnected(int ring, BlockFace direction) { if (this.getDirection(ring) != null) return this.getMetric(ring, direction) == 0; return false; } /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getDirectlyConnected(org.bukkit.block.BlockFace) */ @Override public final int getDirectlyConnected(BlockFace direction) { Set<Integer> rings = getDirectlyConnectedList(direction); return rings.size() == 1 ? rings.iterator().next() : -1 ; } /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getFirstUnknown() */ @Override public final BlockFace getFirstUnknown() { for (BlockFace face : BlockFace.values()) { switch(face) { case NORTH: case EAST: case SOUTH: case WEST: if (this.getDirectlyConnectedList(face).isEmpty()) return face; default: break; } } return null; } /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getDirectlyConnectedList(org.bukkit.block.BlockFace) */ @Override abstract public Set<Integer> getDirectlyConnectedList(BlockFace direction); /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getMetric(int, org.bukkit.block.BlockFace) */ @Override abstract public int getMetric(int entry, BlockFace direction); /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getMinMetric(int) */ @Override abstract public int getMinMetric(int entry); /** * Store a line in the routing table * * @param entry the track number * @param direction the direction to associate * @param metric the metric to associate */ abstract public void setEntry(int entry, BlockFace direction, int metric); /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#isEmpty(int) */ @Override abstract public boolean isEmpty(int entry); /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getOrderedRouteNumbers() */ @Override public abstract Iterator<Integer> getOrderedRouteNumbers(); /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getNotDirectlyConnectedList(org.bukkit.block.BlockFace) */ @Override public abstract Set<Integer> getNotDirectlyConnectedList(BlockFace direction); /** * Remove a line from the routing table * * @param entry the track number * @param from the direction to remove */ abstract public void removeEntry(int entry, BlockFace from); /* (non-Javadoc) * @see com.github.catageek.ByteCartAPI.Wanderer.RoutingTable#getDirection(int) */ @Override abstract public BlockFace getDirection(int entry); }
3,164
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/package-info.java
/** * */ /** * A package that provides the routing layer * */ package com.github.catageek.ByteCart.Routing;
113
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RoutingTableWritable.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RoutingTableWritable.java
package com.github.catageek.ByteCart.Routing; import java.io.IOException; import java.util.Iterator; import java.util.Map; import org.bukkit.block.BlockFace; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.Updaters.UpdaterContent; import com.github.catageek.ByteCartAPI.Wanderer.RoutingTable; /** * A routing table */ public interface RoutingTableWritable extends RoutingTable { /** * Store a line in the routing table * * @param entry the track number * @param direction the direction to associate * @param metric the metric to associate */ public void setEntry(int entry, BlockFace direction, int metric); /** * Remove a line from the routing table * * @param entry the track number * @param from the direction to remove */ public void removeEntry(int entry, BlockFace from); /** * Performs the IGP protocol to update the routing table * * @param neighbour the IGP packet received * @param from the direction from where we received it */ public default void Update(UpdaterContent neighbour, BlockFace from) { // Djikstra algorithm // search for better routes in the received ones int interfacedelay = neighbour.getInterfaceDelay(); for (Map.Entry<Integer, Metric> entry : neighbour.getEntrySet()) { int ring = entry.getKey(); Metric metric = entry.getValue(); int computedmetric = metric.value(); if (interfacedelay > 0) computedmetric += interfacedelay; int routermetric = this.getMetric(ring, from); boolean directlyconnected = (this.getMinMetric(ring) == 0); if ( ! directlyconnected && (routermetric > computedmetric || routermetric < 0)) { this.setEntry(ring, from, computedmetric); if(ByteCart.debug) { ByteCart.log.info("ByteCart : Update : ring = " + ring + ", metric = " + computedmetric + ", direction " + from); } ByteCart.myPlugin.getWandererManager().getFactory("Updater").updateTimestamp(neighbour); } } // search for routes that are no more announced and not directly connected // to remove them Iterator<Integer> it = this.getNotDirectlyConnectedList(from).iterator(); while (it.hasNext()) { Integer route; if(!neighbour.hasRouteTo(route = it.next())) { this.removeEntry(route, from); if(ByteCart.debug) { ByteCart.log.info("ByteCart : Remove : ring = " + route + " from " + from); } ByteCart.myPlugin.getWandererManager().getFactory("Updater").updateTimestamp(neighbour); } } } /** * Clear the routing table * * @param fullreset if set to false, route to entry 0 is kept. */ public void clear(boolean fullreset); /** * Serialize the routing table * * @param allowconversion if set to false, non conversion to another format * @throws IOException */ void serialize(boolean allowconversion) throws IOException; }
2,860
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RoutingTableBook.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RoutingTableBook.java
package com.github.catageek.ByteCart.Routing; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.util.Iterator; import java.util.Map.Entry; import java.util.Set; import java.util.SortedMap; import java.util.SortedSet; import java.util.TreeMap; import java.util.TreeSet; import org.bukkit.block.BlockFace; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.FileStorage.InventoryFile; import com.github.catageek.ByteCart.Storage.ExternalizableTreeMap; import com.github.catageek.ByteCart.Storage.PartitionedHashSet; import com.github.catageek.ByteCartAPI.Util.DirectionRegistry; /** * A routing table in a book */ final class RoutingTableBook extends AbstractRoutingTable implements RoutingTableWritable, Externalizable { private boolean wasModified = false; private ExternalizableTreeMap<RouteNumber, RouteProperty> map = new ExternalizableTreeMap<RouteNumber,RouteProperty>(); private static final long serialVersionUID = -7013741680310224056L; private Inventory inventory; /** * Set the inventory * * @param inventory the inventory */ final void setInventory(Inventory inventory) { this.inventory = inventory; } public RoutingTableBook() { } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#clear(boolean) */ @Override public void clear(boolean fullreset) { if (map.isEmpty()) return; RouteProperty routes = null; RouteNumber route = new RouteNumber(0); if (! fullreset && map.containsKey(route)) routes = map.get(route); map.clear(); if (! fullreset && routes != null) map.put(route, routes); if (ByteCart.debug) ByteCart.log.info("ByteCart : clear routing table map"); wasModified = true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#getRouteNumbers() */ @Override public final Iterator<Integer> getOrderedRouteNumbers() { TreeSet<Integer> newmap = new TreeSet<Integer>(); for(RouteNumber key : map.keySet()) { newmap.add(key.value()); } return ((SortedSet<Integer>) newmap).iterator(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getMetric(int, com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public int getMetric(int entry, BlockFace direction) { SortedMap<Metric, PartitionedHashSet<DirectionRegistry>> smap; RouteNumber route = new RouteNumber(entry); if (map.containsKey(route) && (smap = map.get(route).getMap()) != null && ! smap.isEmpty()) { Iterator<Metric> it = smap.keySet().iterator(); Metric d; while (it.hasNext()) if (smap.get((d = it.next())).contains(new DirectionRegistry(direction))) return d.value(); } return -1; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getMinMetric(int) */ @Override public int getMinMetric(int entry) { SortedMap<Metric, PartitionedHashSet<DirectionRegistry>> smap; RouteNumber route = new RouteNumber(entry); if (map.containsKey(route) && (smap = map.get(route).getMap()) != null && ! smap.isEmpty()) { return smap.firstKey().value(); } return -1; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#setEntry(int, com.github.catageek.ByteCart.Util.DirectionRegistry, com.github.catageek.ByteCart.Routing.Metric) */ private void setMapEntry(int entry, DirectionRegistry direction, Metric metric) { RouteNumber route = new RouteNumber(entry); Metric dist = new Metric(metric); RouteProperty smap; PartitionedHashSet<DirectionRegistry> set; if (metric.value() < this.getMetric(entry, direction.getBlockFace())) { this.removeEntry(entry, direction.getBlockFace()); } if ((smap = map.get(route)) == null) { smap = new RouteProperty(); map.put(route, smap); wasModified = true; } if ((set = smap.getMap().get(dist)) == null) { set = new PartitionedHashSet<DirectionRegistry>(3); smap.getMap().put(dist, set); wasModified = true; } wasModified |= set.add(direction); } private RoutingTableBookJSON convertToJSON() { final RoutingTableBookJSON jtable = new RoutingTableBookJSON(); jtable.setInventory(this.inventory, 0); for (Entry<RouteNumber, RouteProperty> entry : map.entrySet()) { for (Entry<Metric, PartitionedHashSet<DirectionRegistry>> routemap : entry.getValue().getMap().entrySet()) { for (DirectionRegistry route : routemap.getValue()) { jtable.setEntry(entry.getKey().value(), route.getBlockFace(), routemap.getKey().value()); } } } return jtable; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#setEntry(int, com.github.catageek.ByteCart.Util.DirectionRegistry, com.github.catageek.ByteCart.Routing.Metric) */ @Override public void setEntry(int entry, BlockFace direction, int metric) { setMapEntry(entry, new DirectionRegistry(direction), new Metric(metric)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#isEmpty(int) */ @Override public boolean isEmpty(int entry) { return ! map.containsKey(new RouteNumber(entry)); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getDirection(int) */ @Override public BlockFace getDirection(int entry) { RouteNumber route = new RouteNumber(entry); Set<DirectionRegistry> set; TreeMap<Metric, PartitionedHashSet<DirectionRegistry>> pmap; if (map.containsKey(route) && (pmap = map.get(route).getMap()) != null && ! pmap.isEmpty()) { set = pmap.firstEntry().getValue(); if (! set.isEmpty()) return set.toArray(new DirectionRegistry[set.size()])[0].getBlockFace(); throw new AssertionError("Set<DirectionRegistry> in RoutingTableWritable is empty."); } return null; } @Override public BlockFace getAllowedDirection(int entry) { return getDirection(entry); } @Override public Boolean isAllowedDirection(BlockFace direction) { return true; } @Override public void allowDirection(BlockFace direction, Boolean enable) { } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getDirectlyConnectedList(com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public Set<Integer> getDirectlyConnectedList(BlockFace direction) { SortedMap<Integer, Metric> list = new TreeMap<Integer, Metric>(); Iterator<Entry<RouteNumber, RouteProperty>> it = map.entrySet().iterator(); Entry<RouteNumber, RouteProperty> entry; Metric zero = new Metric(0); TreeMap<Metric, PartitionedHashSet<DirectionRegistry>> smap; PartitionedHashSet<DirectionRegistry> set; while (it.hasNext()) { entry = it.next(); if ((smap = entry.getValue().getMap()) != null && smap.containsKey(zero) && ! (set = smap.get(zero)).isEmpty() && set.contains(new DirectionRegistry(direction))) { // just extract the connected route list.put(entry.getKey().value(), zero); } } return list.keySet(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getNotDirectlyConnectedList(com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public Set<Integer> getNotDirectlyConnectedList( BlockFace direction) { SortedMap<Integer, Metric> list = new TreeMap<Integer, Metric>(); Iterator<Entry<RouteNumber, RouteProperty>> it = map.entrySet().iterator(); Entry<RouteNumber, RouteProperty> entry; Metric zero = new Metric(0); Metric one = new Metric(1); SortedMap<Metric, PartitionedHashSet<DirectionRegistry>> smap; PartitionedHashSet<DirectionRegistry> set; while (it.hasNext()) { entry = it.next(); if ((smap = entry.getValue().getMap()) == null || ! (smap = entry.getValue().getMap()).containsKey(zero) || ! (! (set = smap.get(zero)).isEmpty() && set.contains(new DirectionRegistry(direction)))) { // extract routes going to directions with distance > 0 smap = smap.tailMap(one); Iterator<Metric> it2 = smap.keySet().iterator(); while (it2.hasNext()) { Metric d = it2.next(); if (smap.get(d).contains(new DirectionRegistry(direction))) { list.put(entry.getKey().value(), d); break; } } } } return list.keySet(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#removeEntry(int, com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public void removeEntry(int entry, BlockFace from) { RouteNumber route = new RouteNumber(entry); TreeMap<Metric,PartitionedHashSet<DirectionRegistry>> smap; Set<DirectionRegistry> set; if (map.containsKey(route) && (smap = map.get(route).getMap()) != null) { Iterator<Metric> it = smap.keySet().iterator(); while (it.hasNext()) { wasModified |= (set = smap.get(it.next())).remove(new DirectionRegistry(from)); if (set.isEmpty()) it.remove(); if (smap.isEmpty()) map.remove(route); } } } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#serialize() */ @Override public void serialize(boolean allowconversion) throws IOException { if (! wasModified) return; try { // we try to convert to JSON if (allowconversion) { this.convertToJSON().serialize(false); return; } } catch(IOException e) { } // if not possible, try with binary format if (ByteCart.debug) ByteCart.log.info("ByteCart: JSON conversion failed, trying binary format"); InventoryFile file = new InventoryFile(inventory, true, "RoutingTableBinary"); file.setDescription("Bytecart Routing Table"); file.clear(); ObjectOutputStream oos = new ObjectOutputStream(file.getOutputStream()); oos.writeObject(this); if(ByteCart.debug) ByteCart.log.info("ByteCart: binary object written, now closing"); oos.flush(); wasModified = false; } /* (non-Javadoc) * @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @SuppressWarnings("unchecked") @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.map = (ExternalizableTreeMap<RouteNumber, RouteProperty>) in.readObject(); } /* (non-Javadoc) * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput) */ @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(map); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#size() */ @Override public int size() { return map.size(); } }
10,660
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Metric.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/Metric.java
package com.github.catageek.ByteCart.Routing; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import org.apache.commons.lang3.builder.CompareToBuilder; import org.apache.commons.lang3.builder.EqualsBuilder; /** * The metric component of a routing table entry */ public final class Metric implements Comparable<Metric>, Externalizable { /** * */ private static final long serialVersionUID = 7625856925617432369L; private Delay delay; public Metric() { } Metric(Metric m) { this(m.delay.getValue()); } public Metric(int delay) { this.delay = new Delay(delay); } /* (non-Javadoc) * @see java.lang.Comparable#compareTo(java.lang.Object) */ @Override public int compareTo(Metric o) { return new CompareToBuilder().append(value(), o.value()).toComparison(); } /** * @return the value */ public int value() { return delay.getValue(); } /* (non-Javadoc) * @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { delay = (Delay) in.readObject(); } /* (non-Javadoc) * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput) */ @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(delay); } /* (non-Javadoc) * @see java.lang.Object#hashCode() */ @Override public int hashCode() { return value(); } /* (non-Javadoc) * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object o) { if (o == null) return false; if (o == this) return true; if (!(o instanceof Metric)) return false; Metric rhs = (Metric) o; return new EqualsBuilder().append(value(),rhs.value()).isEquals(); } }
1,827
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RoutingTableContent.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RoutingTableContent.java
package com.github.catageek.ByteCart.Routing; import org.apache.commons.lang3.builder.CompareToBuilder; import org.apache.commons.lang3.builder.EqualsBuilder; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; import com.github.catageek.ByteCartAPI.HAL.VirtualRegistry; /** * A raw routing table entry, i.e a registry * * @param <T> the type of content that will be stored */ abstract class RoutingTableContent<T extends RoutingTableContent<T>> implements Comparable<T> { /** * */ private final int length; private final RegistryBoth data; /** * @return the size of the registry in bits */ final int size() { return length; } RoutingTableContent(int length) { this.length = length; data = new VirtualRegistry(length); } RoutingTableContent(int amount, int length) { this(length); this.data.setAmount(amount); } /** * @param amount the value to store */ protected void setValue(int amount) { data.setAmount(amount); } /** * @return the value stored */ public final int value() { return data.getAmount(); } /* (non-Javadoc) * @see java.lang.Comparable#compareTo(java.lang.Object) */ @Override public int compareTo(T o) { return new CompareToBuilder().append(value(), o.value()).toComparison(); } /* (non-Javadoc) * @see java.lang.Object#hashCode() */ @Override public int hashCode() { return value(); } /* (non-Javadoc) * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object o) { if (o == null) return false; if (o == this) return true; if (!(o instanceof RoutingTableContent<?>)) return false; RoutingTableContent<?> rhs = (RoutingTableContent<?>) o; return new EqualsBuilder().append(value(),rhs.value()).isEquals(); } }
1,782
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RoutingTableFactory.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RoutingTableFactory.java
package com.github.catageek.ByteCart.Routing; import java.io.IOException; import java.io.ObjectInputStream; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.FileStorage.InventoryFile; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonSyntaxException; /** * Factory for routing tables */ public final class RoutingTableFactory { /** * Get a routing table * * @param inv the inventory to open * @return the RoutingTableWritable object * @throws IOException * @throws ClassNotFoundException */ static public RoutingTableWritable getRoutingTable(Inventory inv, int slot) throws ClassNotFoundException, IOException, JsonSyntaxException { InventoryFile file = null; if (InventoryFile.isInventoryFile(inv, ".BookFile")) { file = new InventoryFile(inv, true, ".BookFile"); } else if (InventoryFile.isInventoryFile(inv, "RoutingTableBinary")) { file = new InventoryFile(inv, true, "RoutingTableBinary"); } RoutingTableBook rt = null; if (file != null && ! file.isEmpty()) { ObjectInputStream ois = new ObjectInputStream(file.getInputStream()); rt = (RoutingTableBook) ois.readObject(); rt.setInventory(inv); return rt; } if (InventoryFile.isInventoryFile(inv, "RoutingTable")) { file = new InventoryFile(inv, false, "RoutingTable"); } if (file == null || file.isEmpty()) { if (inv.getItem(slot) == null) { return new RoutingTableBookJSON(inv, slot); } throw new IOException("Slot " + slot + " is not empty."); } Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create(); RoutingTableBookJSON rtj = gson.fromJson(file.getPages(), RoutingTableBookJSON.class); rtj.setInventory(inv, slot); return rtj; } }
1,777
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RouteProperty.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RouteProperty.java
package com.github.catageek.ByteCart.Routing; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import java.util.Iterator; import java.util.Map.Entry; import java.util.TreeMap; import com.github.catageek.ByteCart.Storage.PartitionedHashSet; import com.github.catageek.ByteCartAPI.Util.DirectionRegistry; /** * The content of a routing table entry */ final class RouteProperty implements Externalizable { /** * */ private static final long serialVersionUID = -3548458365177323172L; private TreeMap<Metric,PartitionedHashSet<DirectionRegistry>> map = new TreeMap<Metric,PartitionedHashSet<DirectionRegistry>>(); public RouteProperty() { } /** * @return the map associating each metric with a DirectionRegistry */ final TreeMap<Metric,PartitionedHashSet<DirectionRegistry>> getMap() { return map; } /** * Decompose the registry value to a set of DirectionRegistry * * @param value the value to decompose * @return the set */ private final PartitionedHashSet<DirectionRegistry> getPartitionedHashSet(int value) { int reg = value; int cur = 1; PartitionedHashSet<DirectionRegistry> set = new PartitionedHashSet<DirectionRegistry>(); while (reg != 0) { if ((reg & 1) !=0) { set.add(new DirectionRegistry(cur)); } cur = cur << 1; reg = reg >> 1; } return set; } /* (non-Javadoc) * @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @Override public void readExternal(ObjectInput arg0) throws IOException, ClassNotFoundException { int size = arg0.readInt(); for (int i = 0; i < size; i++) { int value = arg0.readUnsignedShort(); PartitionedHashSet<DirectionRegistry> set; if (! (set = getPartitionedHashSet(value & 15)).isEmpty()) { map.put(new Metric(value >> 4), set); } } } /* (non-Javadoc) * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput) */ @Override public void writeExternal(ObjectOutput arg0) throws IOException { arg0.writeInt(map.size()); Iterator<Entry<Metric, PartitionedHashSet<DirectionRegistry>>> it = map.entrySet().iterator(); while (it.hasNext()) { Entry<Metric, PartitionedHashSet<DirectionRegistry>> entry = it.next(); arg0.writeShort((entry.getKey().value() << 4) + entry.getValue().getPartitionedValue()); } } }
2,350
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
Delay.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/Delay.java
package com.github.catageek.ByteCart.Routing; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import com.github.catageek.ByteCartAPI.HAL.RegistryBoth; import com.github.catageek.ByteCartAPI.HAL.VirtualRegistry; /** * A time metric */ class Delay implements Externalizable { /** * */ private static final long serialVersionUID = 970735722356168776L; // hard coded value, if modified, change RouteProperty.writeObject() and readObject() private final RegistryBoth value = new VirtualRegistry(12); public Delay() { } Delay(int value) { this.value.setAmount(value); } /* (non-Javadoc) * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput) */ @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeShort(this.getValue()); } /* (non-Javadoc) * @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.value.setAmount(in.readUnsignedShort()); } /** * @return the value */ int getValue() { return value.getAmount(); } }
1,190
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BCCounter.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/BCCounter.java
package com.github.catageek.ByteCart.Routing; import java.io.Serializable; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCartAPI.Util.DirectionRegistry; import com.github.catageek.ByteCartAPI.Wanderer.Counter; /** * A map containing counters with id */ public final class BCCounter implements Serializable, Counter { /** * */ private static final long serialVersionUID = 6858180714411403984L; private final Map<Integer, Integer> map = new HashMap<Integer,Integer>(); public BCCounter() { } /** * Get a counter by its id * * @param counter * @return the counter */ @Override public int getCount(int counter) { return this.map.containsKey(counter) ? this.map.get(counter) : 0; } /** * Increment the counter by 1 * * @param counter the counter id */ public void incrementCount(int counter) { incrementCount(counter, 1); } /** * Add a value to a counter * * @param counter the counter id * @param value the value to add */ @Override public void incrementCount(int counter, int value) { this.map.put(counter, getCount(counter) + value); } /** * Set the value of a counter * * @param counter the counter id * @param amount the value to set */ @Override public void setCount(int counter, int amount) { this.map.put(counter, amount); } /** * Get the first empty counter id * * @return the id */ public int firstEmpty() { int i = 1; while (getCount(i) != 0) { i++; } return i; } /** * Reset a counter to zero * * @param counter the id of the counter */ public void reset(int counter) { this.map.remove(counter); } /** * Reset all counters to zero */ @Override public void resetAll() { this.map.clear(); } /** * Tell if counters have reached the amount of 64 or more * * @param start the first counter id * @param end the last counter id * @return true if the amont of all counters between start and end (inclusive) are equal or superior to 64 */ @Override public boolean isAllFull(int start, int end) { Iterator<Integer> it = map.keySet().iterator(); int limit = 64; int count; while (it.hasNext()) { if ((count = it.next()) >= start && count <= end && map.get(count) < limit) return false; } return true; } /** * Get the ring number that has the minimum counter value and the direction is different from from parameter * * @param routes the routing table * @param from the direction to exclude from the search * @return the ring number, or 0 if no result */ public int getMinimum(RoutingTableWritable routes, DirectionRegistry from) { Iterator<Integer> it = routes.getOrderedRouteNumbers(); int min = 10000000; //big value int index = -1; while (it.hasNext()) { int ring = it.next(); if (ring == 0) continue; if (! map.containsKey(ring)) return ring; int value; if((value = map.get(ring)) < min && routes.getDirection(ring) != from.getBlockFace() && ring != 0) { min = value; index = ring; } } if(ByteCart.debug) ByteCart.log.info("ByteCart : minimum found ring " + index + " with " + min); return index; } /* (non-Javadoc) * @see java.lang.Object#toString() */ @Override public final String toString() { Iterator<Integer> it = map.keySet().iterator(); String s = ""; while (it.hasNext()) { int ring = it.next(); int count = map.get(ring); s += "ByteCart: Count for ring " + ring + " = " + count + "\n"; } return s; } /** * @return the number of counters the map can contain */ public int getCounterLength() { return 32; } }
3,730
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RouteNumber.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RouteNumber.java
package com.github.catageek.ByteCart.Routing; import java.io.Externalizable; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectOutput; import com.github.catageek.ByteCartAPI.ByteCartAPI; import com.github.catageek.ByteCartAPI.Wanderer.RouteValue; /** * A track number on ByteCartAPI.MAXRINGLOG bits */ final class RouteNumber extends RoutingTableContent<RouteNumber> implements Comparable<RouteNumber>, Externalizable, RouteValue { private static final int rlength = ByteCartAPI.MAXRINGLOG; /** * */ private static final long serialVersionUID = -8112012047943458459L; public RouteNumber() { super(rlength); } RouteNumber(int route) { super(route, rlength); } /* (non-Javadoc) * @see java.io.Externalizable#writeExternal(java.io.ObjectOutput) */ @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeShort(this.value()); } /* (non-Javadoc) * @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.setValue(in.readShort() & ((1 << rlength) - 1)); } }
1,171
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
RoutingTableBookJSON.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/Routing/RoutingTableBookJSON.java
package com.github.catageek.ByteCart.Routing; import java.io.IOException; import java.util.HashSet; import java.util.Iterator; import java.util.Map.Entry; import java.util.Set; import java.util.SortedMap; import java.util.SortedSet; import java.util.TreeMap; import org.bukkit.block.BlockFace; import org.bukkit.inventory.Inventory; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.FileStorage.InventoryFile; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.annotations.Expose; /** * A routing table in a book */ final class RoutingTableBookJSON extends AbstractRoutingTable implements RoutingTableWritable { private boolean wasModified = false; private static class RouteEntry { private @Expose TreeMap<Integer,Set<BlockFace>> routes; RouteEntry() { this.routes = new TreeMap<Integer, Set<BlockFace>>(); } } @Expose private Boolean readonly = false; @Expose private Set<BlockFace> interfaces = new HashSet<>(); @Expose private TreeMap<Integer, RouteEntry> table = new TreeMap<>(); private Inventory inventory; private int slot; /** * Set the inventory * * @param inventory the inventory */ final void setInventory(Inventory inventory, int slot) { this.inventory = inventory; this.slot = slot; } public RoutingTableBookJSON() { } RoutingTableBookJSON(Inventory inv, int slot) { this.inventory = inv; this.slot = slot; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#clear(boolean) */ @Override public void clear(boolean fullreset) { if (table.isEmpty()) return; RouteEntry routes = null; BlockFace route_to_zero = null; if (! fullreset && table.containsKey(0)) { routes = table.get(0); if (this.getMinMetric(0) == 0) { route_to_zero = this.getDirection(0); } } table.clear(); interfaces.clear(); if (! fullreset && routes != null) { table.put(0, routes); if (route_to_zero != null) { interfaces.add(route_to_zero); } } if (ByteCart.debug) ByteCart.log.info("ByteCart : clear routing table table"); wasModified = true; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#getRouteNumbers() */ @Override public final Iterator<Integer> getOrderedRouteNumbers() { Iterator<Integer> it = ((SortedSet<Integer>) table.keySet()).iterator(); return it; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getMetric(int, com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public int getMetric(int entry, BlockFace direction) { SortedMap<Integer, Set<BlockFace>> smap; if (table.containsKey(entry) && (smap = table.get(entry).routes) != null && ! smap.isEmpty()) { Iterator<Integer> it = smap.keySet().iterator(); int d; while (it.hasNext()) if (smap.get((d = it.next())).contains(direction)) return d; } return -1; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getMinMetric(int) */ @Override public int getMinMetric(int entry) { SortedMap<Integer, Set<BlockFace>> smap; if (table.containsKey(entry) && (smap = table.get(entry).routes) != null && ! smap.isEmpty()) { return smap.firstKey(); } return -1; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#setEntry(int, com.github.catageek.ByteCart.Util.DirectionRegistry, com.github.catageek.ByteCart.Routing.Metric) */ private void setMapEntry(int entry, BlockFace direction, int metric) { RouteEntry smap; Set<BlockFace> set; if (metric < this.getMetric(entry, direction)) { this.removeEntry(entry, direction); } if ((smap = table.get(entry)) == null) { smap = new RouteEntry(); table.put(entry, smap); wasModified = true; } if ((set = smap.routes.get(metric)) == null) { set = new HashSet<BlockFace>(3); smap.routes.put(metric, set); wasModified = true; } if (metric == 0) { wasModified |= interfaces.add(direction); } wasModified |= set.add(direction); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#setEntry(int, com.github.catageek.ByteCart.Util.DirectionRegistry, com.github.catageek.ByteCart.Routing.Metric) */ @Override public void setEntry(int entry, BlockFace direction, int metric) { setMapEntry(entry, direction, metric); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#isEmpty(int) */ @Override public boolean isEmpty(int entry) { return ! table.containsKey(entry); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getDirection(int) */ @Override public BlockFace getDirection(int entry) { Set<BlockFace> set; TreeMap<Integer, Set<BlockFace>> pmap; if (table.containsKey(entry) && (pmap = table.get(entry).routes) != null && ! pmap.isEmpty()) { set = pmap.firstEntry().getValue(); if (! set.isEmpty()) return set.toArray(new BlockFace[set.size()])[0]; throw new AssertionError("Set<DirectionRegistry> in RoutingTableWritable is empty."); } return null; } @Override public BlockFace getAllowedDirection(int entry) { TreeMap<Integer, Set<BlockFace>> pmap; if (table.containsKey(entry) && (pmap = table.get(entry).routes) != null) { for (Entry<Integer, Set<BlockFace>> metricroute : pmap.entrySet()) { for (BlockFace direction : metricroute.getValue()) { if (isAllowedDirection(direction)) { return direction; } } } } return null; } @Override public Boolean isAllowedDirection(BlockFace direction) { return interfaces.contains(direction); } @Override public void allowDirection(BlockFace direction, Boolean enable) { this.wasModified |= enable ? interfaces.add(direction) : interfaces.remove(direction); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getDirectlyConnectedList(com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public Set<Integer> getDirectlyConnectedList(BlockFace direction) { SortedMap<Integer, Integer> list = new TreeMap<Integer, Integer>(); Iterator<Entry<Integer, RouteEntry>> it = table.entrySet().iterator(); Entry<Integer, RouteEntry> entry; RouteEntry smap; Set<BlockFace> set; while (it.hasNext()) { entry = it.next(); if ((smap = entry.getValue()) != null && smap.routes.containsKey(0) && ! (set = smap.routes.get(0)).isEmpty() && set.contains(direction)) { // just extract the connected route list.put(entry.getKey(), 0); } } return list.keySet(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#getNotDirectlyConnectedList(com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public Set<Integer> getNotDirectlyConnectedList(BlockFace direction) { SortedMap<Integer, Integer> list = new TreeMap<Integer, Integer>(); Iterator<Entry<Integer, RouteEntry>> it = table.entrySet().iterator(); Entry<Integer, RouteEntry> entry; SortedMap<Integer, Set<BlockFace>> smap; Set<BlockFace> set; while (it.hasNext()) { entry = it.next(); if ((smap = entry.getValue().routes) == null || ! (smap = entry.getValue().routes).containsKey(0) || ! (! (set = smap.get(0)).isEmpty() && set.contains(direction))) { // extract routes going to directions with distance > 0 smap = smap.tailMap(1); Iterator<Integer> it2 = smap.keySet().iterator(); while (it2.hasNext()) { int d = it2.next(); if (smap.get(d).contains(direction)) { list.put(entry.getKey(), d); break; } } } } return list.keySet(); } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.AbstractRoutingTable#removeEntry(int, com.github.catageek.ByteCart.Util.DirectionRegistry) */ @Override public void removeEntry(int entry, BlockFace from) { TreeMap<Integer, Set<BlockFace>> smap; Set<BlockFace> set; if (table.containsKey(entry) && (smap = table.get(entry).routes) != null) { Iterator<Integer> it = smap.keySet().iterator(); while (it.hasNext()) { int metric = it.next(); if (metric == 0) { wasModified |= interfaces.remove(from); } wasModified |= (set = smap.get(metric)).remove(from); if (set.isEmpty()) it.remove(); if (smap.isEmpty()) table.remove(entry); } } } private RoutingTableBook convertToBinary() { final RoutingTableBook btable = new RoutingTableBook(); btable.setInventory(this.inventory); for (Entry<Integer, RouteEntry> entry : table.entrySet()) { for (Entry<Integer, Set<BlockFace>> routemap : entry.getValue().routes.entrySet()) { for (BlockFace route : routemap.getValue()) { btable.setEntry(entry.getKey().intValue(), route, routemap.getKey().intValue()); } } } return btable; } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#serialize() */ @Override public void serialize(boolean allowconversion) throws IOException { if (! this.wasModified || this.readonly) return; if (ByteCart.debug) ByteCart.log.info("ByteCart: Trying to store in JSON format"); Gson gson = new GsonBuilder().setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create(); String json = gson.toJson(this); InventoryFile file = new InventoryFile(inventory, false, "RoutingTable"); file.setDescription("Bytecart Routing Table"); file.clear(); file.getOutputStream().write(json.getBytes()); try { file.flush(); } catch (IOException e) { if (allowconversion) { this.convertToBinary().serialize(false); } else throw e; } /* wasModified = false; if (ByteCart.debug) ByteCart.log.info("Storing in JSON format successful"); */ } /* (non-Javadoc) * @see com.github.catageek.ByteCart.Routing.RoutingTableWritable#size() */ @Override public int size() { return table.size(); } }
10,016
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
package-info.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/plugins/package-info.java
/** * */ /** * A package that provides addons to ByteCart */ package com.github.catageek.ByteCart.plugins;
111
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
searchObsoleteMarkers.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/plugins/searchObsoleteMarkers.java
package com.github.catageek.ByteCart.plugins; import java.util.Iterator; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.block.Block; import org.dynmap.markers.Marker; import com.github.catageek.ByteCart.HAL.AbstractIC; /** * Synchronous task to remove markers */ final class searchObsoleteMarkers implements Runnable { /* (non-Javadoc) * @see java.lang.Runnable#run() */ @Override public void run() { Iterator<Marker> it = BCDynmapPlugin.markerset.getMarkers().iterator(); int x, y, z; while (it.hasNext()) { Marker m = it.next(); x = Location.locToBlock(m.getX()); y = Location.locToBlock(m.getY()); z = Location.locToBlock(m.getZ()); Block block = Bukkit.getServer().getWorld(m.getWorld()).getBlockAt(x, y, z); if (! AbstractIC.checkEligibility(block)) m.deleteMarker(); } } }
851
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BCWandererTracker.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/plugins/BCWandererTracker.java
package com.github.catageek.ByteCart.plugins; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import org.bukkit.Location; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; import org.bukkit.command.TabCompleter; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.vehicle.VehicleMoveEvent; import com.github.catageek.ByteCart.Util.LogUtil; import com.github.catageek.ByteCartAPI.Event.UpdaterCreateEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterMoveEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterRemoveEvent; public final class BCWandererTracker implements Listener, CommandExecutor, TabCompleter { private Map<Integer,Location> locations = new HashMap<>(); @EventHandler public void onUpdaterCreate(UpdaterCreateEvent event) { locations.put(event.getVehicleId(), event.getLocation()); } @EventHandler public void onUpdaterMove(UpdaterMoveEvent event) { VehicleMoveEvent e = event.getEvent(); locations.put(e.getVehicle().getEntityId(), e.getTo()); } @EventHandler public void onUpdaterRemove(UpdaterRemoveEvent event) { locations.remove(event.getVehicleId()); } @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { if (locations.isEmpty()) { LogUtil.sendSuccess(sender, "No updaters found"); return true; } sender.sendMessage("List of locations of updaters:"); for (Location loc : locations.values()) { StringBuilder s = new StringBuilder(); s.append("World: ").append(loc.getWorld().getName()).append(" "); s.append("X: ").append(loc.getBlockX()).append(" "); s.append("Y: ").append(loc.getBlockY()).append(" "); s.append("Z: ").append(loc.getBlockZ()); LogUtil.sendSuccess(sender, s.toString()); } return true; } @Override public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) { return Collections.emptyList(); } }
2,080
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z
BCDynmapPlugin.java
/FileExtraction/Java_unseen/catageek_ByteCart/src/com/github/catageek/ByteCart/plugins/BCDynmapPlugin.java
package com.github.catageek.ByteCart.plugins; import java.io.IOException; import java.io.InputStream; import java.util.MissingResourceException; import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.block.Block; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.vehicle.VehicleMoveEvent; import org.dynmap.DynmapCommonAPI; import org.dynmap.markers.Marker; import org.dynmap.markers.MarkerAPI; import org.dynmap.markers.MarkerIcon; import org.dynmap.markers.MarkerSet; import com.github.catageek.ByteCart.ByteCart; import com.github.catageek.ByteCart.AddressLayer.AddressFactory; import com.github.catageek.ByteCartAPI.AddressLayer.Address; import com.github.catageek.ByteCartAPI.Event.SignCreateEvent; import com.github.catageek.ByteCartAPI.Event.SignRemoveEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterClearStationEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterCreateEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterMoveEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterPassStationEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterRemoveEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterSetStationEvent; import com.github.catageek.ByteCartAPI.Event.UpdaterSignInvalidateEvent; import com.github.catageek.ByteCartAPI.HAL.IC; import com.github.catageek.ByteCartAPI.Signs.BCSign; import com.github.catageek.ByteCartAPI.Signs.Station; /** * A Dynmap addon */ public final class BCDynmapPlugin implements Listener { private static final String name = ByteCart.myPlugin.getConfig().getString("dynmap.layer", "ByteCart"); static MarkerSet markerset; private static MarkerIcon defaulticon; private static MarkerIcon erroricon; private static MarkerIcon updatericon; public BCDynmapPlugin() { DynmapCommonAPI api = (DynmapCommonAPI) Bukkit.getPluginManager().getPlugin("dynmap"); MarkerAPI markerapi = null; try { markerapi = api.getMarkerAPI(); } catch (NullPointerException e) { throw new MissingResourceException("Dynmap plugin is not present, please install it or set dynmap = false in config file", MarkerAPI.class.getName(), "dynmap"); } if (markerapi == null) throw new MissingResourceException("Dynmap API could not be loaded", MarkerAPI.class.getName(), "dynmap"); defaulticon = loadIcon(markerapi,"bytecart_station", "station", "resources/bc2.png"); if (defaulticon == null) { throw new MissingResourceException("Station icon could not be loaded", MarkerAPI.class.getName(), "station"); } erroricon = loadIcon(markerapi,"bytecart_error", "error", "resources/error.png"); if (erroricon == null) { throw new MissingResourceException("Error icon could not be loaded", MarkerAPI.class.getName(), "error"); } updatericon = loadIcon(markerapi,"bytecart_updater", "updater", "resources/updater.png"); if (updatericon == null) { throw new MissingResourceException("Updater icon could not be loaded", MarkerAPI.class.getName(), "updater"); } markerset = markerapi.getMarkerSet(name); if (markerset == null) { markerset = markerapi.createMarkerSet(name, name, null, true); markerset.addAllowedMarkerIcon(defaulticon); markerset.addAllowedMarkerIcon(erroricon); markerset.addAllowedMarkerIcon(updatericon); markerset.setDefaultMarkerIcon(defaulticon); } } /** * Load the ByteCart icon * * @param markerapi dynmap marker API * @param id the id of the icon * @param label the label * @param file the file to load * @return the icon loaded */ private MarkerIcon loadIcon(MarkerAPI markerapi, String id, String label, String file) { MarkerIcon icon = markerapi.getMarkerIcon(id); if (icon == null) { try (InputStream png = getClass().getResourceAsStream(file)) { icon = markerapi.createMarkerIcon(id, label, png); } catch (IOException e) { throw new MissingResourceException("ByteCart : icon could not be loaded", this.getClass().getName(), file); } } return icon; } /** * Updates the map if a station is updated * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterSetStation(UpdaterSetStationEvent event) { Block block = event.getIc().getBlock(); Marker marker = markerset.findMarker(buildId(block)); if (marker != null) marker.deleteMarker(); Address address = event.getNewAddress(); selectAndAddMarker(event.getName(), block, address); } /** * Check that marker information about the station is correct, or fix it * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterPassStation(UpdaterPassStationEvent event) { Block block = event.getIc().getBlock(); Address address = event.getAddress(); Marker marker = markerset.findMarker(buildId(block)); if (marker != null) { if (address.isValid() && checkMarkerInformation(marker, block, address.toString(), event.getIc().getFriendlyName())) return; marker.deleteMarker(); } selectAndAddMarker(event.getName(), block, address); } /** * Delete the marker if the station sign is cleared * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterClearStation(UpdaterClearStationEvent event) { deleteMarker(event); } /** * Delete the marker * * @param event */ private void deleteMarker(UpdaterEvent event) { Block block = event.getIc().getBlock(); Marker marker = markerset.findMarker(buildId(block)); if (marker != null) marker.deleteMarker(); } /** * Delete the marker if the sign is removed * * @param event */ @EventHandler(ignoreCancelled = true) public void onSignRemove(SignRemoveEvent event) { IC ic; if (! ((ic = event.getIc()) instanceof BCSign)) return; Block block = ic.getBlock(); Marker marker = markerset.findMarker(buildId(block)); if (marker != null) marker.deleteMarker(); } /** * Delete the marker if invalid * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterSignInvalidate(UpdaterSignInvalidateEvent event) { deleteMarker(event); } /** * Create a marker for manually created signs * * @param event */ @EventHandler(ignoreCancelled = true) public void onSignCreate(SignCreateEvent event) { IC ic; if (! ((ic = event.getIc()) instanceof Station)) return; Block block = ic.getBlock(); String address = event.getStrings()[3]; Marker marker = markerset.findMarker(buildId(block)); if (marker != null) marker.deleteMarker(); selectAndAddMarker(event.getStrings()[2], block, AddressFactory.getAddress(address)); } /** * Create a marker for new updaters * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterCreate(UpdaterCreateEvent event) { Marker marker = markerset.findMarker(String.valueOf(event.getVehicleId())); if (marker != null) { marker.deleteMarker(); } addMarker(String.valueOf(event.getVehicleId()), "Updater", event.getLocation(), updatericon); } /** * Move a marker of updater * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterMove(UpdaterMoveEvent event) { VehicleMoveEvent mve = event.getEvent(); int id = mve.getVehicle().getEntityId(); Location loc = mve.getTo(); Marker marker = markerset.findMarker(String.valueOf(id)); if (marker != null) { marker.setLocation(loc.getWorld().getName(), loc.getX(), loc.getY(), loc.getZ()); } } /** * Delete a marker of updater * * @param event */ @EventHandler(ignoreCancelled = true) public void onUpdaterRemove(UpdaterRemoveEvent event) { Marker marker = markerset.findMarker(String.valueOf(event.getVehicleId())); if (marker != null) { marker.deleteMarker(); } } /** * Register the marker with the right icon * * @param friendlyname the name to write * @param block the block * @param address the address to write */ private static void selectAndAddMarker(String friendlyname, Block block, Address address) { MarkerIcon icon; String label; if (address.isValid()) { icon = defaulticon; label = buildLabel(address.toString(), friendlyname); } else { icon = erroricon; label = "Error setting address for " + friendlyname; } addMarker(label, block.getLocation(), icon); } /** * Create the marker using API * * @param label the label to write * @param block the block * @param markericon the icon to draw */ private static void addMarker(String label, Location loc, MarkerIcon markericon) { addMarker(loc.toString(), label, loc, markericon); } /** * Create the marker using API * * @param label the label to write * @param block the block * @param markericon the icon to draw */ private static void addMarker(String key, String label, Location loc, MarkerIcon markericon) { markerset.createMarker(key, label, loc.getWorld().getName(), loc.getX(), loc.getY(), loc.getZ(), markericon, true); } /** * Build a sting containing name and address * * @param address the address * @param friendlyname the name * @return a string containing "name (address)" */ private static String buildLabel(String address, String friendlyname) { if (friendlyname.equals("")) { return address; } return friendlyname + " (" + address + ")"; } /** * Get a string used as unique id for a marker * * @param block the block * @return A unique string for the block */ private static String buildId(Block block) { return block.getLocation().toString(); } /** * Check marker information consistency * * @param marker the marker to check * @param block the block to check against * @param address the address to check against * @param friendlyName the name to check against * @return true if information is matching */ private static boolean checkMarkerInformation(Marker marker, Block block, String address, String friendlyName) { boolean ret = false; ret &= (block.getX() == marker.getX()); ret &= (block.getY() == marker.getY()); ret &= (block.getZ() == marker.getZ()); ret &= (buildLabel(address, friendlyName).equals(marker.getLabel())); return ret; } /** * Search for stations that do not exist anymore and * remove corresponding markers. * */ public static void removeObsoleteMarkers() { if (markerset != null) Bukkit.getScheduler().runTask(ByteCart.myPlugin, new searchObsoleteMarkers()); } }
10,486
Java
.java
catageek/ByteCart
28
9
5
2012-03-11T08:15:46Z
2018-10-18T04:55:47Z