GabrielTofvesson/SpigotPortals
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move comparators to separate file

Browse Source
This commit is contained in:
Gabriel Tofvesson 2021-09-24 02:12:53 +02:00
parent 42276fa5ab
commit 88ef59de6b
2 changed files with 63 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/main/kotlin/Comparator.kt Normal file
View File

@ -0,0 +1,62 @@
import org.bukkit.Location
import org.bukkit.OfflinePlayer
import java.util.*
import kotlin.Comparator
typealias Comparison<V> = (V) -> Int
val COMPARATOR_PLAYER = Comparator<OfflinePlayer> { a, b -> a.uniqueId.compareTo(b.uniqueId) }
val COMPARATOR_LOCATION = Comparator<Location> { a, b -> a.compareByOrder(b, { world!!.uid }, Location::getBlockX, Location::getBlockY, Location::getBlockZ) }
val COMPARATOR_UUID = Comparator<UUID?> { a, b ->
val aUnlinked = a == null
val bUnlinked = a == null
if (aUnlinked || bUnlinked) {
return@Comparator if (aUnlinked == bUnlinked) 0 else if (aUnlinked) -1 else 1
}
a!!.compareTo(b!!)
}
// An owner cannot place two portals on the same block, implying that this comparator defines a partial order
val COMPARATOR_PORTAL_LOCATION_OWNER = Comparator<Portal> { a, b -> a.compareByOrder(b, { world.uid }, Portal::x, Portal::y, Portal::z, { owner.uniqueId }) }
val COMPARATOR_PORTAL_LOCATION = Comparator<Portal> { a, b -> a.compareByOrder(b, { world.uid }, Portal::x, Portal::y, Portal::z) }
val COMPARATOR_PORTAL_OWNER_NAME = Comparator<Portal> { a, b -> a.compareByOrder(b, { owner.uniqueId }, Portal::name) }
val COMPARATOR_PORTAL_LINKS = Comparator<Portal> { a, b -> COMPARATOR_UUID.compare(a.link, b.link) }
val Location.COMPARISON_PORTAL: Comparison<Portal>
get() = {
compareValues(
world!!::getUID to it.world::getUID,
this::getBlockX to it::x,
this::getBlockY to it::y,
this::getBlockZ to it::z
)
}
val OfflinePlayer.COMPARISON_PORTAL: Comparison<Portal>
get() = { uniqueId.compareTo(it.owner.uniqueId) }
val UUID.COMPARISON_PORTAL_ID: Comparison<Portal>
get() = { compareTo(it.id) }
val Portal.COMPARISON_PORTAL_LINKEDTO: Comparison<Portal>
get() = { COMPARATOR_UUID.compare(id, it.link) }
// IDs are unique, so this comparator inherently defines a partial order
val COMPARATOR_PORTAL_UID = Comparator<Portal> { a, b -> a.id.compareTo(b.id) }
val COMPARATOR_INVITE_RECIPIENT = Comparator<Invite> { a, b ->
a.compareByOrder(b, { recipient.uniqueId }, Invite::portalID)
}
val COMPARATOR_INVITE_PORTAL = Comparator<Invite> { a, b ->
a.compareByOrder(b, Invite::portalID, { recipient.uniqueId })
}
val OfflinePlayer.COMPARISON_INVITE: Comparison<Invite>
get() = { uniqueId.compareTo(it.recipient.uniqueId) }
val Portal.COMPARISON_INVITE: Comparison<Invite>
get() = { id.compareTo(it.portalID) }

10
src/main/kotlin/Portal.kt
View File

@ -4,19 +4,11 @@ import org.bukkit.World
import org.bukkit.entity.Player
import java.nio.ByteBuffer
import java.util.*
import kotlin.Comparator
import kotlin.experimental.and
import kotlin.experimental.inv
import kotlin.experimental.or
private val PLAYER_COMPARATOR = Comparator<OfflinePlayer> { a, b -> a.uniqueId.compareTo(b.uniqueId) }
val LOCATION_COMPARATOR = Comparator<Location> { a, b -> a.compareByOrder(b, { world!!.uid }, Location::getBlockX, Location::getBlockY, Location::getBlockZ) }
// An owner cannot place two portals on the same block, implying that this comparator defines a partial order
val PORTAL_LOCATION_COMPARATOR = Comparator<Portal> { a, b -> a.compareByOrder(b, { world.uid }, Portal::x, Portal::y, Portal::z, { owner.uniqueId }) }
// IDs are unique, so this comparator inherently defines a partial order
val PORTAL_UID_COMPARATOR = Comparator<Portal> { a, b -> a.id.compareTo(b.id) }
private val threadLocalInputBuffer = ThreadLocal.withInitial { ReallocatingBuffer(ByteBuffer.allocate(96)) }
private val threadLocalOutputBuffer = ThreadLocal.withInitial { ReallocatingBuffer(ByteBuffer.allocate(96)) }