From f646c04d0935212bc6c2a1b126f93f0759110568 Mon Sep 17 00:00:00 2001 From: Luck Date: Sun, 7 Jan 2018 18:40:02 +0000 Subject: [PATCH] Remove lombok from the project --- CONTRIBUTING.md | 3 - README.md | 2 - .../me/lucko/luckperms/api/ChatMetaType.java | 13 +- .../java/me/lucko/luckperms/api/Contexts.java | 54 ++- .../lucko/luckperms/api/DataMutateResult.java | 6 +- .../java/me/lucko/luckperms/api/Tristate.java | 2 +- .../luckperms/api/caching/MetaContexts.java | 27 +- .../api/context/AbstractContextSet.java | 15 +- .../luckperms/api/context/ContextManager.java | 3 - .../luckperms/api/context/ContextSet.java | 8 +- .../api/context/ImmutableContextSet.java | 41 ++- .../api/context/MutableContextSet.java | 54 ++- .../luckperms/api/platform/PlatformType.java | 2 +- bukkit/pom.xml | 17 +- .../bukkit/BukkitCommandExecutor.java | 4 +- .../luckperms/bukkit/BukkitConfigAdapter.java | 16 +- .../bukkit/BukkitSchedulerAdapter.java | 76 ++-- .../luckperms/bukkit/BukkitSenderFactory.java | 18 +- .../luckperms/bukkit/LPBukkitPlugin.java | 282 ++++++++++----- .../calculators/BukkitCalculatorFactory.java | 31 +- .../bukkit/compat/ReflectionUtil.java | 8 +- .../bukkit/contexts/BukkitContextManager.java | 8 +- .../bukkit/contexts/WorldCalculator.java | 14 +- .../listeners/BukkitConnectionListener.java | 59 ++-- .../listeners/BukkitPlatformListener.java | 17 +- .../messaging/BungeeMessagingService.java | 14 +- .../messaging/LilyPadMessagingService.java | 10 +- .../migration/BukkitMigrationUtils.java | 7 +- .../migration/MigrationBPermissions.java | 3 +- .../migration/MigrationGroupManager.java | 3 +- .../migration/MigrationPermissionsBukkit.java | 3 +- .../migration/MigrationPermissionsEx.java | 3 +- .../migration/MigrationPowerfulPerms.java | 3 +- .../migration/MigrationZPermissions.java | 3 +- .../bukkit/model/DummyPermissible.java | 9 +- .../luckperms/bukkit/model/LPPermissible.java | 125 +++++-- .../bukkit/model/LPPermissionAttachment.java | 92 ++--- .../bukkit/model/LPSubscriptionMap.java | 37 +- .../bukkit/model/PermissibleInjector.java | 7 +- .../bukkit/model/SubscriptionMapInjector.java | 17 +- .../processors/BukkitProcessorsSetupTask.java | 15 +- .../processors/ChildPermissionProvider.java | 8 +- .../bukkit/processors/ChildProcessor.java | 15 +- .../bukkit/processors/DefaultsProcessor.java | 12 +- .../bukkit/processors/DefaultsProvider.java | 24 +- .../bukkit/vault/AbstractVaultChat.java | 28 +- .../bukkit/vault/AbstractVaultPermission.java | 2 +- .../luckperms/bukkit/vault/VaultChatHook.java | 75 ++-- .../bukkit/vault/VaultHookManager.java | 38 +- .../bukkit/vault/VaultPermissionHook.java | 96 +++--- bungee/pom.xml | 7 +- .../bungee/BungeeCommandExecutor.java | 8 +- .../luckperms/bungee/BungeeConfigAdapter.java | 16 +- .../bungee/BungeeSchedulerAdapter.java | 14 +- .../luckperms/bungee/LPBungeePlugin.java | 222 +++++++++--- .../calculators/BungeeCalculatorFactory.java | 17 +- .../contexts/BackendServerCalculator.java | 14 +- .../bungee/contexts/BungeeContextManager.java | 8 +- .../contexts/RedisBungeeCalculator.java | 5 +- .../bungee/event/TristateCheckEvent.java | 41 ++- .../listeners/BungeeConnectionListener.java | 49 +-- .../BungeePermissionCheckListener.java | 19 +- .../messaging/BungeeMessagingService.java | 10 +- .../RedisBungeeMessagingService.java | 12 +- .../migration/MigrationBungeePerms.java | 3 +- .../bungee/util/RedisBungeeUtil.java | 7 +- common/pom.xml | 7 +- .../common/actionlog/ExtendedLogEntry.java | 136 +++++--- .../lucko/luckperms/common/actionlog/Log.java | 37 +- .../common/actionlog/LogDispatcher.java | 37 +- .../lucko/luckperms/common/api/ApiUtils.java | 7 +- .../common/api/LuckPermsApiProvider.java | 44 ++- .../delegates/manager/ApiContextManager.java | 86 +++-- .../delegates/manager/ApiGroupManager.java | 24 +- .../delegates/manager/ApiTrackManager.java | 24 +- .../api/delegates/manager/ApiUserManager.java | 35 +- .../api/delegates/misc/ApiActionLogger.java | 28 +- .../api/delegates/misc/ApiConfiguration.java | 27 +- .../delegates/misc/ApiMetaStackFactory.java | 28 +- .../api/delegates/misc/ApiNodeFactory.java | 40 ++- .../api/delegates/misc/ApiPlatformInfo.java | 20 +- .../api/delegates/misc/ApiUuidCache.java | 25 +- .../common/api/delegates/model/ApiGroup.java | 48 +-- .../common/api/delegates/model/ApiLog.java | 167 +++++---- .../delegates/model/ApiPermissionHolder.java | 238 ++++++++----- .../api/delegates/model/ApiStorage.java | 131 ++++--- .../common/api/delegates/model/ApiTrack.java | 84 +++-- .../common/api/delegates/model/ApiUser.java | 47 ++- .../assignments/AssignmentExpression.java | 10 +- .../common/assignments/AssignmentRule.java | 60 +++- .../luckperms/common/backup/DummySender.java | 17 +- .../luckperms/common/backup/Exporter.java | 52 +-- .../luckperms/common/backup/Importer.java | 73 ++-- .../luckperms/common/buffers/Buffer.java | 69 ++-- .../common/buffers/BufferedRequest.java | 66 ++-- .../lucko/luckperms/common/buffers/Cache.java | 36 +- .../common/buffers/UpdateTaskBuffer.java | 2 +- .../common/bulkupdate/BulkUpdate.java | 65 +++- .../common/bulkupdate/BulkUpdateBuilder.java | 26 +- .../luckperms/common/bulkupdate/DataType.java | 22 +- .../bulkupdate/action/DeleteAction.java | 10 +- .../bulkupdate/action/UpdateAction.java | 22 +- .../comparisons/ComparisonType.java | 12 +- .../bulkupdate/constraint/Constraint.java | 44 ++- .../bulkupdate/constraint/QueryField.java | 13 +- .../common/caching/GroupCachedData.java | 2 +- .../common/caching/HolderCachedData.java | 155 +++++---- .../common/caching/UserCachedData.java | 2 +- .../caching/handlers/CachedStateManager.java | 20 +- .../common/caching/type/MetaAccumulator.java | 57 ++- .../common/caching/type/MetaCache.java | 68 +++- .../common/caching/type/PermissionCache.java | 44 ++- .../AbstractCalculatorFactory.java | 4 +- .../calculators/PermissionCalculator.java | 25 +- .../PermissionCalculatorMetadata.java | 26 +- .../lucko/luckperms/common/commands/Arg.java | 27 +- .../common/commands/ArgumentPermissions.java | 7 +- .../common/commands/CommandManager.java | 32 +- .../common/commands/CommandPermission.java | 19 +- .../common/commands/CommandResult.java | 11 +- .../common/commands/abstraction/Command.java | 30 +- .../commands/abstraction/MainCommand.java | 12 +- .../abstraction/SharedMainCommand.java | 22 +- .../abstraction/SharedSubCommand.java | 29 +- .../commands/abstraction/SubCommand.java | 3 - .../impl/generic/meta/MetaAddChatMeta.java | 10 +- .../generic/meta/MetaAddTempChatMeta.java | 10 +- .../commands/impl/generic/meta/MetaClear.java | 2 +- .../commands/impl/generic/meta/MetaInfo.java | 3 +- .../impl/generic/meta/MetaRemoveChatMeta.java | 18 +- .../generic/meta/MetaRemoveTempChatMeta.java | 18 +- .../impl/generic/other/HolderEditor.java | 3 +- .../impl/generic/other/HolderShowTracks.java | 3 +- .../impl/generic/parent/ParentInfo.java | 3 +- .../impl/generic/parent/ParentSetTrack.java | 2 +- .../generic/permission/PermissionInfo.java | 3 +- .../commands/impl/group/CreateGroup.java | 2 +- .../commands/impl/group/DeleteGroup.java | 2 +- .../commands/impl/group/GroupClone.java | 3 +- .../common/commands/impl/group/GroupInfo.java | 3 +- .../commands/impl/group/GroupListMembers.java | 3 +- .../commands/impl/group/GroupMainCommand.java | 2 +- .../commands/impl/group/GroupRename.java | 3 +- .../impl/group/GroupSetDisplayName.java | 3 +- .../commands/impl/log/LogGroupHistory.java | 3 +- .../commands/impl/log/LogMainCommand.java | 2 +- .../common/commands/impl/log/LogNotify.java | 5 +- .../common/commands/impl/log/LogRecent.java | 5 +- .../common/commands/impl/log/LogSearch.java | 3 +- .../commands/impl/log/LogTrackHistory.java | 3 +- .../commands/impl/log/LogUserHistory.java | 3 +- .../impl/migration/MigrationMainCommand.java | 19 +- .../impl/migration/MigrationUtils.java | 7 +- .../commands/impl/misc/ApplyEditsCommand.java | 3 +- .../commands/impl/misc/BulkUpdateCommand.java | 4 +- .../commands/impl/misc/CheckCommand.java | 3 +- .../commands/impl/misc/ExportCommand.java | 6 +- .../commands/impl/misc/ImportCommand.java | 6 +- .../impl/misc/ReloadConfigCommand.java | 3 +- .../commands/impl/misc/SearchCommand.java | 3 +- .../commands/impl/misc/TreeCommand.java | 5 +- .../commands/impl/track/CreateTrack.java | 2 +- .../commands/impl/track/DeleteTrack.java | 2 +- .../commands/impl/track/TrackAppend.java | 3 +- .../commands/impl/track/TrackClear.java | 3 +- .../commands/impl/track/TrackClone.java | 3 +- .../common/commands/impl/track/TrackInfo.java | 3 +- .../commands/impl/track/TrackInsert.java | 3 +- .../commands/impl/track/TrackMainCommand.java | 2 +- .../commands/impl/track/TrackRemove.java | 3 +- .../commands/impl/track/TrackRename.java | 3 +- .../common/commands/impl/user/UserClone.java | 3 +- .../common/commands/impl/user/UserInfo.java | 3 +- .../commands/impl/user/UserMainCommand.java | 2 +- .../impl/user/UserSwitchPrimaryGroup.java | 3 +- .../commands/sender/AbstractSender.java | 60 ++-- .../common/commands/sender/SenderFactory.java | 21 +- .../common/commands/utils/ArgumentUtils.java | 25 +- .../common/commands/utils/CommandUtils.java | 8 +- .../common/commands/utils/SortMode.java | 18 +- .../common/config/AbstractConfiguration.java | 49 ++- .../luckperms/common/config/ConfigKeys.java | 5 +- .../luckperms/common/config/ContextsFile.java | 38 +- .../adapter/AbstractConfigurationAdapter.java | 14 +- .../common/config/keys/AbstractKey.java | 13 +- .../common/config/keys/BooleanKey.java | 14 +- .../common/config/keys/EnduringKey.java | 18 +- .../common/config/keys/IntegerKey.java | 14 +- .../config/keys/LowercaseStringKey.java | 14 +- .../luckperms/common/config/keys/MapKey.java | 13 +- .../common/config/keys/StaticKey.java | 13 +- .../common/config/keys/StringKey.java | 14 +- .../contexts/AbstractContextManager.java | 55 +-- .../ContextSetConfigurateSerializer.java | 7 +- .../contexts/ContextSetJsonSerializer.java | 10 +- .../common/contexts/LuckPermsCalculator.java | 16 +- .../common/dependencies/Dependency.java | 15 +- .../dependencies/DependencyManager.java | 18 +- .../luckperms/common/event/AbstractEvent.java | 16 +- .../luckperms/common/event/EventFactory.java | 6 +- .../common/event/LuckPermsEventBus.java | 39 ++- .../common/event/LuckPermsEventHandler.java | 40 ++- .../common/event/impl/EventConfigReload.java | 7 +- .../event/impl/EventGroupCacheLoad.java | 30 +- .../common/event/impl/EventGroupCreate.java | 30 +- .../event/impl/EventGroupDataRecalculate.java | 30 +- .../common/event/impl/EventGroupDelete.java | 37 +- .../common/event/impl/EventGroupLoad.java | 23 +- .../common/event/impl/EventGroupLoadAll.java | 7 +- .../common/event/impl/EventLogBroadcast.java | 37 +- .../event/impl/EventLogNetworkPublish.java | 37 +- .../common/event/impl/EventLogNotify.java | 84 +++-- .../common/event/impl/EventLogPublish.java | 30 +- .../common/event/impl/EventLogReceive.java | 30 +- .../common/event/impl/EventNodeAdd.java | 49 ++- .../common/event/impl/EventNodeClear.java | 41 ++- .../common/event/impl/EventNodeRemove.java | 48 ++- .../common/event/impl/EventPostSync.java | 7 +- .../event/impl/EventPreNetworkSync.java | 30 +- .../common/event/impl/EventPreSync.java | 23 +- .../common/event/impl/EventTrackAddGroup.java | 44 ++- .../common/event/impl/EventTrackClear.java | 37 +- .../common/event/impl/EventTrackCreate.java | 30 +- .../common/event/impl/EventTrackDelete.java | 37 +- .../common/event/impl/EventTrackLoad.java | 23 +- .../common/event/impl/EventTrackLoadAll.java | 7 +- .../event/impl/EventTrackRemoveGroup.java | 44 ++- .../common/event/impl/EventUserCacheLoad.java | 30 +- .../event/impl/EventUserDataRecalculate.java | 30 +- .../common/event/impl/EventUserDemote.java | 43 ++- .../event/impl/EventUserFirstLogin.java | 30 +- .../common/event/impl/EventUserLoad.java | 23 +- .../event/impl/EventUserLoginProcess.java | 36 +- .../common/event/impl/EventUserPromote.java | 43 ++- .../luckperms/common/locale/CommandSpec.java | 27 +- .../common/locale/CommandSpecData.java | 57 ++- .../luckperms/common/locale/Message.java | 11 +- .../common/locale/NoopLocaleManager.java | 2 +- .../common/locale/SimpleLocaleManager.java | 8 +- .../common/logging/ProgressLogger.java | 35 +- .../common/logging/SenderLogger.java | 31 +- .../common/managers/AbstractManager.java | 18 +- .../common/managers/GenericGroupManager.java | 9 +- .../common/managers/GenericTrackManager.java | 9 +- .../common/managers/GenericUserManager.java | 35 +- .../messaging/AbstractMessagingService.java | 66 ++-- .../common/messaging/MessagingFactory.java | 33 +- .../messaging/RedisMessagingService.java | 27 +- .../common/metastacking/SimpleMetaStack.java | 25 +- .../SimpleMetaStackDefinition.java | 72 ++-- .../metastacking/SimpleMetaStackEntry.java | 63 +++- .../metastacking/StandardStackElements.java | 181 +++++++--- .../lucko/luckperms/common/model/Group.java | 63 +++- .../common/model/PermissionHolder.java | 324 +++++++++--------- .../lucko/luckperms/common/model/Track.java | 95 +++-- .../me/lucko/luckperms/common/model/User.java | 76 ++-- .../common/node/ImmutableLocalizedNode.java | 249 +++++++++++++- .../luckperms/common/node/ImmutableNode.java | 117 ++++--- .../common/node/ImmutableTransientNode.java | 245 ++++++++++++- .../common/node/InheritanceInfo.java | 49 ++- .../common/node/LegacyNodeFactory.java | 7 +- .../luckperms/common/node/NodeBuilder.java | 37 +- .../luckperms/common/node/NodeFactory.java | 7 +- .../common/node/NodeHeldPermission.java | 65 +++- .../luckperms/common/node/NodeModel.java | 42 +-- .../luckperms/common/node/NodeTools.java | 7 +- .../node/NodeWithContextComparator.java | 6 +- .../common/node/ShorthandParser.java | 7 +- .../AllParentsByWeightHolder.java | 8 +- .../CachedPrimaryGroupHolder.java | 4 +- .../GroupInheritanceComparator.java | 14 +- .../primarygroup/ParentsByWeightHolder.java | 8 +- .../common/primarygroup/StoredHolder.java | 13 +- .../common/processors/MapProcessor.java | 2 +- .../common/processors/RegexProcessor.java | 6 +- .../common/processors/WildcardProcessor.java | 6 +- .../common/references/GroupReference.java | 42 ++- .../common/references/HolderType.java | 18 +- .../common/references/UserIdentifier.java | 39 ++- .../common/references/UserReference.java | 41 ++- .../common/storage/AbstractStorage.java | 87 +++-- .../common/storage/DataConstraints.java | 25 +- .../common/storage/StorageCredentials.java | 62 +++- .../common/storage/StorageFactory.java | 74 ++-- .../luckperms/common/storage/StorageType.java | 11 +- .../common/storage/dao/AbstractDao.java | 21 +- .../common/storage/dao/SplitStorageDao.java | 58 ++-- .../storage/dao/file/ConfigurateDao.java | 160 ++++----- .../storage/dao/file/FileUuidCache.java | 10 +- .../common/storage/dao/file/FileWatcher.java | 51 ++- .../dao/legacy/LegacyJsonMigration.java | 48 +-- .../dao/legacy/LegacySqlMigration.java | 77 +++-- .../dao/legacy/LegacyYamlMigration.java | 48 +-- .../common/storage/dao/mongodb/MongoDao.java | 92 +++-- .../common/storage/dao/sql/SqlDao.java | 243 ++++++------- .../connection/AbstractConnectionFactory.java | 13 +- .../file/FlatfileConnectionFactory.java | 10 +- .../file/NonClosableConnection.java | 297 +++++++++++++++- .../hikari/HikariConnectionFactory.java | 30 +- .../hikari/MySqlConnectionFactory.java | 8 +- .../hikari/PostgreConnectionFactory.java | 8 +- .../wrappings/BufferedOutputStorage.java | 158 +++++++-- .../storage/wrappings/PhasedStorage.java | 147 ++++---- .../common/tasks/CacheHousekeepingTask.java | 11 +- .../common/tasks/ExpireTemporaryTask.java | 17 +- .../luckperms/common/tasks/UpdateTask.java | 28 +- .../common/treeview/ImmutableTreeNode.java | 12 +- .../common/treeview/PermissionVault.java | 37 +- .../luckperms/common/treeview/TreeNode.java | 16 +- .../luckperms/common/treeview/TreeView.java | 12 +- .../common/treeview/TreeViewBuilder.java | 30 +- .../lucko/luckperms/common/utils/Cycle.java | 18 +- .../luckperms/common/utils/DateUtil.java | 8 +- .../common/utils/HikariSupplier.java | 32 +- .../common/utils/ImmutableCollectors.java | 7 +- .../luckperms/common/utils/LoginHelper.java | 9 +- .../luckperms/common/utils/PatternCache.java | 13 +- .../luckperms/common/utils/Predicates.java | 7 +- .../luckperms/common/utils/SafeIterator.java | 7 +- .../luckperms/common/utils/Scripting.java | 7 +- .../luckperms/common/utils/TextUtils.java | 19 +- .../luckperms/common/utils/UuidCache.java | 24 +- .../luckperms/common/verbose/CheckData.java | 37 +- .../luckperms/common/verbose/CheckOrigin.java | 12 +- .../common/verbose/VerboseFilter.java | 7 +- .../common/verbose/VerboseHandler.java | 26 +- .../common/verbose/VerboseListener.java | 55 +-- .../common/webeditor/WebEditorUtils.java | 7 +- pom.xml | 1 - sponge/pom.xml | 7 - sponge/sponge-service-api6/pom.xml | 7 - .../api6/PermissionDescriptionProxy.java | 30 +- .../proxy/api6/PermissionServiceProxy.java | 46 ++- .../proxy/api6/SimpleDescriptionBuilder.java | 89 +++-- .../proxy/api6/SubjectCollectionProxy.java | 48 ++- .../service/proxy/api6/SubjectDataProxy.java | 49 ++- .../service/proxy/api6/SubjectProxy.java | 58 ++-- sponge/sponge-service-api7/pom.xml | 7 - .../api7/PermissionDescriptionProxy.java | 35 +- .../proxy/api7/PermissionServiceProxy.java | 66 ++-- .../proxy/api7/SimpleDescriptionBuilder.java | 89 +++-- .../proxy/api7/SubjectCollectionProxy.java | 75 ++-- .../service/proxy/api7/SubjectDataProxy.java | 54 ++- .../service/proxy/api7/SubjectProxy.java | 58 ++-- sponge/sponge-service/pom.xml | 7 - .../sponge/service/CompatibilityUtil.java | 18 +- .../DelegatingImmutableContextSet.java | 31 +- .../context/DelegatingMutableContextSet.java | 49 +-- .../service/model/SubjectReference.java | 44 ++- .../model/SubjectReferenceFactory.java | 49 ++- .../luckperms/sponge/LPSpongePlugin.java | 311 ++++++++++++----- .../sponge/SpongeCommandExecutor.java | 22 +- .../luckperms/sponge/SpongeConfigAdapter.java | 6 +- .../sponge/SpongeSchedulerAdapter.java | 22 +- .../calculators/SpongeCalculatorFactory.java | 29 +- .../sponge/commands/OptionClear.java | 3 +- .../luckperms/sponge/commands/OptionInfo.java | 3 +- .../luckperms/sponge/commands/OptionSet.java | 3 +- .../sponge/commands/OptionUnset.java | 3 +- .../luckperms/sponge/commands/ParentAdd.java | 3 +- .../sponge/commands/ParentClear.java | 3 +- .../luckperms/sponge/commands/ParentInfo.java | 3 +- .../sponge/commands/ParentRemove.java | 3 +- .../sponge/commands/PermissionClear.java | 3 +- .../sponge/commands/PermissionInfo.java | 3 +- .../sponge/commands/SpongeCommandUtils.java | 7 +- .../sponge/commands/SpongeMainCommand.java | 10 +- .../contexts/ProxiedContextCalculator.java | 14 +- .../sponge/contexts/SpongeContextManager.java | 8 +- .../sponge/contexts/WorldCalculator.java | 14 +- .../listeners/SpongeConnectionListener.java | 45 +-- .../listeners/SpongePlatformListener.java | 9 +- .../sponge/managers/SpongeGroupManager.java | 52 +-- .../sponge/managers/SpongeUserManager.java | 69 ++-- .../messaging/BungeeMessagingService.java | 20 +- .../migration/MigrationPermissionManager.java | 3 +- .../migration/MigrationPermissionsEx.java | 3 +- .../migration/SpongeMigrationUtils.java | 7 +- .../luckperms/sponge/model/SpongeGroup.java | 46 +-- .../luckperms/sponge/model/SpongeUser.java | 46 +-- .../processors/GroupDefaultsProcessor.java | 12 +- .../processors/SpongeWildcardProcessor.java | 2 +- .../processors/UserDefaultsProcessor.java | 12 +- .../LuckPermsPermissionDescription.java | 72 ++-- .../sponge/service/LuckPermsService.java | 93 +++-- .../sponge/service/LuckPermsSubjectData.java | 221 ++++++------ .../sponge/service/ProxyFactory.java | 7 +- .../calculated/CalculatedSubjectData.java | 130 +++---- .../service/legacy/LegacyDataMigrator.java | 21 +- .../service/legacy/SubjectDataHolder.java | 9 +- .../service/persisted/OptionLookupKey.java | 48 ++- .../persisted/PermissionLookupKey.java | 48 ++- .../persisted/PersistedCollection.java | 40 ++- .../service/persisted/PersistedSubject.java | 115 ++++--- .../persisted/PersistedSubjectData.java | 19 +- .../service/storage/SubjectStorage.java | 20 +- .../service/storage/SubjectStorageModel.java | 14 +- .../tasks/ServiceCacheHousekeepingTask.java | 9 +- 398 files changed, 8485 insertions(+), 4821 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index e648eca21..5edbf7b55 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -11,9 +11,6 @@ If you're unsure, feel free to ask using the above resources BEFORE making a rep Bugs or issues should be reported using the [GitHub Issues tab](https://github.com/lucko/LuckPerms/issues). ### :pencil: Want to contribute code? - -In order to contribute to and make changes to the plugin, you will need the dependencies listed in the [README](https://github.com/lucko/LuckPerms), plus the [Lombok plugin](https://projectlombok.org/download.html) for your IDE. - #### Pull Requests If you make any changes or improvements to the plugin which you think would be beneficial to others, please consider making a pull request to merge your changes back into the upstream project. (especially if your changes are bug fixes!) diff --git a/README.md b/README.md index 7e6053595..d0ef43d15 100644 --- a/README.md +++ b/README.md @@ -32,8 +32,6 @@ mvn clean package You can find the output jars in the `target` directories. ## Contributing -In order to contribute to and make changes to the plugin, you will need the dependencies listed above, plus the [Lombok plugin](https://projectlombok.org/download.html) for your IDE. - #### Pull Requests If you make any changes or improvements to the plugin which you think would be beneficial to others, please consider making a pull request to merge your changes back into the upstream project. (especially if your changes are bug fixes!) diff --git a/api/src/main/java/me/lucko/luckperms/api/ChatMetaType.java b/api/src/main/java/me/lucko/luckperms/api/ChatMetaType.java index cdcabc980..2d97b16b3 100644 --- a/api/src/main/java/me/lucko/luckperms/api/ChatMetaType.java +++ b/api/src/main/java/me/lucko/luckperms/api/ChatMetaType.java @@ -25,9 +25,8 @@ package me.lucko.luckperms.api; -import com.google.common.base.Preconditions; - import java.util.Map; +import java.util.Objects; import java.util.Optional; import javax.annotation.Nonnull; @@ -45,13 +44,13 @@ public enum ChatMetaType { PREFIX("prefix") { @Override public boolean matches(@Nonnull Node node) { - return Preconditions.checkNotNull(node, "node").isPrefix(); + return Objects.requireNonNull(node, "node").isPrefix(); } @Nonnull @Override public Map.Entry getEntry(@Nonnull Node node) { - return Preconditions.checkNotNull(node, "node").getPrefix(); + return Objects.requireNonNull(node, "node").getPrefix(); } }, @@ -61,13 +60,13 @@ public enum ChatMetaType { SUFFIX("suffix") { @Override public boolean matches(@Nonnull Node node) { - return Preconditions.checkNotNull(node, "node").isSuffix(); + return Objects.requireNonNull(node, "node").isSuffix(); } @Nonnull @Override public Map.Entry getEntry(@Nonnull Node node) { - return Preconditions.checkNotNull(node, "node").getSuffix(); + return Objects.requireNonNull(node, "node").getSuffix(); } }; @@ -107,7 +106,7 @@ public enum ChatMetaType { @Override public String toString() { - return str; + return this.str; } /** diff --git a/api/src/main/java/me/lucko/luckperms/api/Contexts.java b/api/src/main/java/me/lucko/luckperms/api/Contexts.java index b1cb7af30..0665819f4 100644 --- a/api/src/main/java/me/lucko/luckperms/api/Contexts.java +++ b/api/src/main/java/me/lucko/luckperms/api/Contexts.java @@ -25,11 +25,11 @@ package me.lucko.luckperms.api; -import com.google.common.base.Preconditions; - import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.api.context.ImmutableContextSet; +import java.util.Objects; + import javax.annotation.Nonnull; import javax.annotation.concurrent.Immutable; @@ -89,6 +89,7 @@ public class Contexts { return GLOBAL; } + @Nonnull public static Contexts of(@Nonnull ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) { return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op); } @@ -135,7 +136,7 @@ public class Contexts { private final int hashCode; public Contexts(@Nonnull ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) { - this.context = Preconditions.checkNotNull(context, "context").makeImmutable(); + this.context = Objects.requireNonNull(context, "context").makeImmutable(); this.includeGlobal = includeGlobal; this.includeGlobalWorld = includeGlobalWorld; this.applyGroups = applyGroups; @@ -211,18 +212,17 @@ public class Contexts { return this.applyGlobalWorldGroups; } - @Override @Nonnull + @Override public String toString() { return "Contexts(" + - "context=" + this.getContexts() + ", " + - "op=" + this.isOp() + ", " + - "includeGlobal=" + this.isIncludeGlobal() + ", " + - "includeGlobalWorld=" + this.isIncludeGlobalWorld() + ", " + - "applyGroups=" + this.isApplyGroups() + ", " + - "applyGlobalGroups=" + this.isApplyGlobalGroups() + ", " + - "applyGlobalWorldGroups=" + this.isApplyGlobalWorldGroups() + - ")"; + "context=" + this.context + ", " + + "op=" + this.op + ", " + + "includeGlobal=" + this.includeGlobal + ", " + + "includeGlobalWorld=" + this.includeGlobalWorld + ", " + + "applyGroups=" + this.applyGroups + ", " + + "applyGlobalGroups=" + this.applyGlobalGroups + ", " + + "applyGlobalWorldGroups=" + this.applyGlobalWorldGroups + ")"; } @Override @@ -230,33 +230,23 @@ public class Contexts { if (o == this) return true; if (o == allowAll()) return false; if (!(o instanceof Contexts)) return false; + final Contexts that = (Contexts) o; - final Contexts other = (Contexts) o; - return this.getContexts().equals(other.getContexts()) && - this.isOp() == other.isOp() && - this.isIncludeGlobal() == other.isIncludeGlobal() && - this.isIncludeGlobalWorld() == other.isIncludeGlobalWorld() && - this.isApplyGroups() == other.isApplyGroups() && - this.isApplyGlobalGroups() == other.isApplyGlobalGroups() && - this.isApplyGlobalWorldGroups() == other.isApplyGlobalWorldGroups(); + return this.context.equals(that.context) && + this.op == that.op && + this.includeGlobal == that.includeGlobal && + this.includeGlobalWorld == that.includeGlobalWorld && + this.applyGroups == that.applyGroups && + this.applyGlobalGroups == that.applyGlobalGroups && + this.applyGlobalWorldGroups == that.applyGlobalWorldGroups; } private int calculateHashCode() { - final int PRIME = 59; - int result = 1; - final Object contexts = this.getContexts(); - result = result * PRIME + contexts.hashCode(); - result = result * PRIME + (this.isOp() ? 79 : 97); - result = result * PRIME + (this.isIncludeGlobal() ? 79 : 97); - result = result * PRIME + (this.isIncludeGlobalWorld() ? 79 : 97); - result = result * PRIME + (this.isApplyGroups() ? 79 : 97); - result = result * PRIME + (this.isApplyGlobalGroups() ? 79 : 97); - result = result * PRIME + (this.isApplyGlobalWorldGroups() ? 79 : 97); - return result; + return Objects.hash(this.context, this.op, this.includeGlobal, this.includeGlobalWorld, this.applyGroups, this.applyGlobalGroups, this.applyGlobalWorldGroups); } @Override public int hashCode() { - return hashCode; + return this.hashCode; } } diff --git a/api/src/main/java/me/lucko/luckperms/api/DataMutateResult.java b/api/src/main/java/me/lucko/luckperms/api/DataMutateResult.java index 374939862..0d9a3aa3a 100644 --- a/api/src/main/java/me/lucko/luckperms/api/DataMutateResult.java +++ b/api/src/main/java/me/lucko/luckperms/api/DataMutateResult.java @@ -62,7 +62,7 @@ public enum DataMutateResult { * @return a boolean representation */ public boolean asBoolean() { - return value; + return this.value; } /** @@ -72,7 +72,7 @@ public enum DataMutateResult { * @since 3.4 */ public boolean wasSuccess() { - return value; + return this.value; } /** @@ -82,7 +82,7 @@ public enum DataMutateResult { * @since 3.4 */ public boolean wasFailure() { - return !value; + return !this.value; } } diff --git a/api/src/main/java/me/lucko/luckperms/api/Tristate.java b/api/src/main/java/me/lucko/luckperms/api/Tristate.java index e56440070..bd05e3533 100644 --- a/api/src/main/java/me/lucko/luckperms/api/Tristate.java +++ b/api/src/main/java/me/lucko/luckperms/api/Tristate.java @@ -96,6 +96,6 @@ public enum Tristate { * @return a boolean representation of the Tristate. */ public boolean asBoolean() { - return booleanValue; + return this.booleanValue; } } diff --git a/api/src/main/java/me/lucko/luckperms/api/caching/MetaContexts.java b/api/src/main/java/me/lucko/luckperms/api/caching/MetaContexts.java index 1b53b4be7..0b1e7282c 100644 --- a/api/src/main/java/me/lucko/luckperms/api/caching/MetaContexts.java +++ b/api/src/main/java/me/lucko/luckperms/api/caching/MetaContexts.java @@ -25,11 +25,11 @@ package me.lucko.luckperms.api.caching; -import com.google.common.base.Preconditions; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.metastacking.MetaStackDefinition; +import java.util.Objects; + import javax.annotation.Nonnull; import javax.annotation.concurrent.Immutable; @@ -71,9 +71,9 @@ public final class MetaContexts { * @param suffixStackDefinition the suffix stack definition to be used */ public MetaContexts(@Nonnull Contexts contexts, @Nonnull MetaStackDefinition prefixStackDefinition, @Nonnull MetaStackDefinition suffixStackDefinition) { - this.contexts = Preconditions.checkNotNull(contexts, "contexts"); - this.prefixStackDefinition = Preconditions.checkNotNull(prefixStackDefinition, "prefixStackDefinition"); - this.suffixStackDefinition = Preconditions.checkNotNull(suffixStackDefinition, "suffixStackDefinition"); + this.contexts = Objects.requireNonNull(contexts, "contexts"); + this.prefixStackDefinition = Objects.requireNonNull(prefixStackDefinition, "prefixStackDefinition"); + this.suffixStackDefinition = Objects.requireNonNull(suffixStackDefinition, "suffixStackDefinition"); this.hashCode = calculateHashCode(); } @@ -106,23 +106,18 @@ public final class MetaContexts { public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof MetaContexts)) return false; - final MetaContexts other = (MetaContexts) o; - return this.getContexts().equals(other.getContexts()) && - this.getPrefixStackDefinition().equals(other.getPrefixStackDefinition()) && - this.getSuffixStackDefinition().equals(other.getSuffixStackDefinition()); + final MetaContexts that = (MetaContexts) o; + return this.contexts.equals(that.contexts) && + this.prefixStackDefinition.equals(that.prefixStackDefinition) && + this.suffixStackDefinition.equals(that.suffixStackDefinition); } private int calculateHashCode() { - final int PRIME = 59; - int result = 1; - result = result * PRIME + this.getContexts().hashCode(); - result = result * PRIME + this.getPrefixStackDefinition().hashCode(); - result = result * PRIME + this.getSuffixStackDefinition().hashCode(); - return result; + return Objects.hash(this.contexts, this.prefixStackDefinition, this.suffixStackDefinition); } @Override public int hashCode() { - return hashCode; + return this.hashCode; } } diff --git a/api/src/main/java/me/lucko/luckperms/api/context/AbstractContextSet.java b/api/src/main/java/me/lucko/luckperms/api/context/AbstractContextSet.java index 342e1a5c5..b9c0334c2 100644 --- a/api/src/main/java/me/lucko/luckperms/api/context/AbstractContextSet.java +++ b/api/src/main/java/me/lucko/luckperms/api/context/AbstractContextSet.java @@ -31,12 +31,11 @@ import com.google.common.collect.Multimap; import java.util.Collection; import java.util.Map; +import java.util.Objects; import java.util.Set; import javax.annotation.Nonnull; -import static com.google.common.base.Preconditions.checkNotNull; - abstract class AbstractContextSet implements ContextSet { protected abstract Multimap backing(); @@ -104,14 +103,14 @@ abstract class AbstractContextSet implements ContextSet { public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof ContextSet)) return false; - final ContextSet other = (ContextSet) o; + final ContextSet that = (ContextSet) o; final Multimap otherContexts; - if (other instanceof AbstractContextSet) { - otherContexts = ((AbstractContextSet) other).backing(); + if (that instanceof AbstractContextSet) { + otherContexts = ((AbstractContextSet) that).backing(); } else { - otherContexts = other.toMultimap(); + otherContexts = that.toMultimap(); } return backing().equals(otherContexts); @@ -123,11 +122,11 @@ abstract class AbstractContextSet implements ContextSet { } static String sanitizeKey(String key) { - return checkNotNull(key, "key is null").toLowerCase().intern(); + return Objects.requireNonNull(key, "key is null").toLowerCase().intern(); } static String sanitizeValue(String value) { - return checkNotNull(value, "value is null").intern(); + return Objects.requireNonNull(value, "value is null").intern(); } } diff --git a/api/src/main/java/me/lucko/luckperms/api/context/ContextManager.java b/api/src/main/java/me/lucko/luckperms/api/context/ContextManager.java index 2ff0f1e4c..4018b2bd6 100644 --- a/api/src/main/java/me/lucko/luckperms/api/context/ContextManager.java +++ b/api/src/main/java/me/lucko/luckperms/api/context/ContextManager.java @@ -153,7 +153,6 @@ public interface ContextManager { * * @param calculator the calculator */ - @Nonnull void registerCalculator(@Nonnull ContextCalculator calculator); /** @@ -163,7 +162,6 @@ public interface ContextManager { * * @param calculator the calculator */ - @Nonnull void registerStaticCalculator(@Nonnull StaticContextCalculator calculator); /** @@ -171,7 +169,6 @@ public interface ContextManager { * * @param subject the subject */ - @Nonnull void invalidateCache(@Nonnull Object subject); } diff --git a/api/src/main/java/me/lucko/luckperms/api/context/ContextSet.java b/api/src/main/java/me/lucko/luckperms/api/context/ContextSet.java index caf088ab5..0ede2d2e1 100644 --- a/api/src/main/java/me/lucko/luckperms/api/context/ContextSet.java +++ b/api/src/main/java/me/lucko/luckperms/api/context/ContextSet.java @@ -25,10 +25,10 @@ package me.lucko.luckperms.api.context; -import com.google.common.base.Preconditions; import com.google.common.collect.Multimap; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.Set; @@ -302,7 +302,7 @@ public interface ContextSet { * @throws NullPointerException if the key or value is null */ default boolean has(@Nonnull Map.Entry entry) { - Preconditions.checkNotNull(entry, "entry"); + Objects.requireNonNull(entry, "entry"); return has(entry.getKey(), entry.getValue()); } @@ -317,7 +317,7 @@ public interface ContextSet { * @throws NullPointerException if the key or value is null */ default boolean hasIgnoreCase(@Nonnull Map.Entry entry) { - Preconditions.checkNotNull(entry, "entry"); + Objects.requireNonNull(entry, "entry"); return hasIgnoreCase(entry.getKey(), entry.getValue()); } @@ -358,7 +358,7 @@ public interface ContextSet { return true; } - Preconditions.checkNotNull(other, "other"); + Objects.requireNonNull(other, "other"); if (this.isEmpty()) { // this is empty, so is therefore always satisfied. return true; diff --git a/api/src/main/java/me/lucko/luckperms/api/context/ImmutableContextSet.java b/api/src/main/java/me/lucko/luckperms/api/context/ImmutableContextSet.java index 51f04c05c..e60929bf0 100644 --- a/api/src/main/java/me/lucko/luckperms/api/context/ImmutableContextSet.java +++ b/api/src/main/java/me/lucko/luckperms/api/context/ImmutableContextSet.java @@ -29,13 +29,12 @@ import com.google.common.collect.ImmutableSetMultimap; import com.google.common.collect.Multimap; import java.util.Map; +import java.util.Objects; import java.util.Set; import javax.annotation.Nonnull; import javax.annotation.concurrent.Immutable; -import static com.google.common.base.Preconditions.checkNotNull; - /** * An immutable implementation of {@link ContextSet}. * @@ -99,7 +98,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public static ImmutableContextSet fromEntries(@Nonnull Iterable> iterable) { - checkNotNull(iterable, "iterable"); + Objects.requireNonNull(iterable, "iterable"); ImmutableContextSet.Builder builder = builder(); for (Map.Entry entry : iterable) { builder.add(entry); @@ -116,7 +115,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public static ImmutableContextSet fromMap(@Nonnull Map map) { - return fromEntries(checkNotNull(map, "map").entrySet()); + return fromEntries(Objects.requireNonNull(map, "map").entrySet()); } /** @@ -129,7 +128,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public static ImmutableContextSet fromMultimap(@Nonnull Multimap multimap) { - return fromEntries(checkNotNull(multimap, "multimap").entries()); + return fromEntries(Objects.requireNonNull(multimap, "multimap").entries()); } /** @@ -143,7 +142,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public static ImmutableContextSet fromSet(@Nonnull ContextSet contextSet) { - return checkNotNull(contextSet, "contextSet").makeImmutable(); + return Objects.requireNonNull(contextSet, "contextSet").makeImmutable(); } /** @@ -161,12 +160,12 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con ImmutableContextSet(ImmutableSetMultimap contexts) { this.map = contexts; - this.hashCode = map.hashCode(); + this.hashCode = this.map.hashCode(); } @Override protected Multimap backing() { - return map; + return this.map; } @Override @@ -190,18 +189,18 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con @Nonnull @Override public Set> toSet() { - return map.entries(); + return this.map.entries(); } @Nonnull @Override public Multimap toMultimap() { - return map; + return this.map; } @Override public int hashCode() { - return hashCode; + return this.hashCode; } @Override @@ -222,10 +221,10 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con } private synchronized ImmutableSetMultimap.Builder builder() { - if (builder == null) { - builder = ImmutableSetMultimap.builder(); + if (this.builder == null) { + this.builder = ImmutableSetMultimap.builder(); } - return builder; + return this.builder; } private void put(String key, String value) { @@ -257,7 +256,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public Builder add(@Nonnull Map.Entry entry) { - checkNotNull(entry, "entry"); + Objects.requireNonNull(entry, "entry"); add(entry.getKey(), entry.getValue()); return this; } @@ -272,7 +271,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public Builder addAll(@Nonnull Iterable> iterable) { - for (Map.Entry e : checkNotNull(iterable, "iterable")) { + for (Map.Entry e : Objects.requireNonNull(iterable, "iterable")) { add(e); } return this; @@ -288,7 +287,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public Builder addAll(@Nonnull Map map) { - addAll(checkNotNull(map, "map").entrySet()); + addAll(Objects.requireNonNull(map, "map").entrySet()); return this; } @@ -303,7 +302,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public Builder addAll(@Nonnull Multimap multimap) { - addAll(checkNotNull(multimap, "multimap").entries()); + addAll(Objects.requireNonNull(multimap, "multimap").entries()); return this; } @@ -317,7 +316,7 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public Builder addAll(@Nonnull ContextSet contextSet) { - checkNotNull(contextSet, "contextSet"); + Objects.requireNonNull(contextSet, "contextSet"); if (contextSet instanceof AbstractContextSet) { AbstractContextSet other = ((AbstractContextSet) contextSet); if (!other.isEmpty()) { @@ -337,10 +336,10 @@ public final class ImmutableContextSet extends AbstractContextSet implements Con */ @Nonnull public ImmutableContextSet build() { - if (builder == null) { + if (this.builder == null) { return empty(); } else { - return new ImmutableContextSet(builder.build()); + return new ImmutableContextSet(this.builder.build()); } } } diff --git a/api/src/main/java/me/lucko/luckperms/api/context/MutableContextSet.java b/api/src/main/java/me/lucko/luckperms/api/context/MutableContextSet.java index b3f7d94f3..5e2bd6106 100644 --- a/api/src/main/java/me/lucko/luckperms/api/context/MutableContextSet.java +++ b/api/src/main/java/me/lucko/luckperms/api/context/MutableContextSet.java @@ -25,7 +25,6 @@ package me.lucko.luckperms.api.context; -import com.google.common.base.Preconditions; import com.google.common.collect.HashMultimap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.ImmutableSetMultimap; @@ -35,12 +34,11 @@ import com.google.common.collect.SetMultimap; import java.util.Collection; import java.util.Map; +import java.util.Objects; import java.util.Set; import javax.annotation.Nonnull; -import static com.google.common.base.Preconditions.checkNotNull; - /** * A mutable implementation of {@link ContextSet}. * @@ -58,8 +56,8 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ @Nonnull public static MutableContextSet singleton(@Nonnull String key, @Nonnull String value) { - checkNotNull(key, "key"); - checkNotNull(value, "value"); + Objects.requireNonNull(key, "key"); + Objects.requireNonNull(value, "value"); MutableContextSet set = MutableContextSet.create(); set.add(key, value); return set; @@ -78,10 +76,10 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ @Nonnull public static MutableContextSet of(@Nonnull String key1, @Nonnull String value1, @Nonnull String key2, @Nonnull String value2) { - checkNotNull(key1, "key1"); - checkNotNull(value1, "value1"); - checkNotNull(key2, "key2"); - checkNotNull(value2, "value2"); + Objects.requireNonNull(key1, "key1"); + Objects.requireNonNull(value1, "value1"); + Objects.requireNonNull(key2, "key2"); + Objects.requireNonNull(value2, "value2"); MutableContextSet set = create(); set.add(key1, value1); set.add(key2, value2); @@ -97,7 +95,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ @Nonnull public static MutableContextSet fromEntries(@Nonnull Iterable> iterable) { - checkNotNull(iterable, "iterable"); + Objects.requireNonNull(iterable, "iterable"); MutableContextSet set = create(); set.addAll(iterable); return set; @@ -112,7 +110,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ @Nonnull public static MutableContextSet fromMap(@Nonnull Map map) { - checkNotNull(map, "map"); + Objects.requireNonNull(map, "map"); MutableContextSet set = create(); set.addAll(map); return set; @@ -128,7 +126,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ @Nonnull public static MutableContextSet fromMultimap(@Nonnull Multimap multimap) { - checkNotNull(multimap, "multimap"); + Objects.requireNonNull(multimap, "multimap"); MutableContextSet set = create(); set.addAll(multimap); return set; @@ -145,7 +143,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ @Nonnull public static MutableContextSet fromSet(@Nonnull ContextSet contextSet) { - Preconditions.checkNotNull(contextSet, "contextSet"); + Objects.requireNonNull(contextSet, "contextSet"); MutableContextSet set = create(); set.addAll(contextSet); return set; @@ -173,7 +171,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte @Override protected Multimap backing() { - return map; + return this.map; } @Override @@ -185,10 +183,10 @@ public final class MutableContextSet extends AbstractContextSet implements Conte @Override public ImmutableContextSet makeImmutable() { // if the map is empty, don't create a new instance - if (map.isEmpty()) { + if (this.map.isEmpty()) { return ImmutableContextSet.empty(); } - return new ImmutableContextSet(ImmutableSetMultimap.copyOf(map)); + return new ImmutableContextSet(ImmutableSetMultimap.copyOf(this.map)); } @Nonnull @@ -200,13 +198,13 @@ public final class MutableContextSet extends AbstractContextSet implements Conte @Nonnull @Override public Set> toSet() { - return ImmutableSet.copyOf(map.entries()); + return ImmutableSet.copyOf(this.map.entries()); } @Nonnull @Override public Multimap toMultimap() { - return ImmutableSetMultimap.copyOf(map); + return ImmutableSetMultimap.copyOf(this.map); } /** @@ -217,7 +215,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if the key or value is null */ public void add(@Nonnull String key, @Nonnull String value) { - map.put(sanitizeKey(key), sanitizeValue(value)); + this.map.put(sanitizeKey(key), sanitizeValue(value)); } /** @@ -227,7 +225,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if the entry is null */ public void add(@Nonnull Map.Entry entry) { - checkNotNull(entry, "entry"); + Objects.requireNonNull(entry, "entry"); add(entry.getKey(), entry.getValue()); } @@ -238,7 +236,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if iterable is null */ public void addAll(@Nonnull Iterable> iterable) { - for (Map.Entry e : checkNotNull(iterable, "iterable")) { + for (Map.Entry e : Objects.requireNonNull(iterable, "iterable")) { add(e); } } @@ -250,7 +248,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if the map is null */ public void addAll(@Nonnull Map map) { - addAll(checkNotNull(map, "map").entrySet()); + addAll(Objects.requireNonNull(map, "map").entrySet()); } /** @@ -261,7 +259,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @since 3.4 */ public void addAll(@Nonnull Multimap multimap) { - addAll(checkNotNull(multimap, "multimap").entries()); + addAll(Objects.requireNonNull(multimap, "multimap").entries()); } /** @@ -271,7 +269,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if the contextSet is null */ public void addAll(@Nonnull ContextSet contextSet) { - checkNotNull(contextSet, "contextSet"); + Objects.requireNonNull(contextSet, "contextSet"); if (contextSet instanceof AbstractContextSet) { AbstractContextSet other = ((AbstractContextSet) contextSet); this.map.putAll(other.backing()); @@ -288,7 +286,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if the key or value is null */ public void remove(@Nonnull String key, @Nonnull String value) { - map.remove(sanitizeKey(key), sanitizeValue(value)); + this.map.remove(sanitizeKey(key), sanitizeValue(value)); } /** @@ -300,7 +298,7 @@ public final class MutableContextSet extends AbstractContextSet implements Conte */ public void removeIgnoreCase(@Nonnull String key, @Nonnull String value) { String v = sanitizeValue(value); - Collection strings = map.asMap().get(sanitizeKey(key)); + Collection strings = this.map.asMap().get(sanitizeKey(key)); if (strings != null) { strings.removeIf(e -> e.equalsIgnoreCase(v)); } @@ -313,14 +311,14 @@ public final class MutableContextSet extends AbstractContextSet implements Conte * @throws NullPointerException if the key is null */ public void removeAll(@Nonnull String key) { - map.removeAll(sanitizeKey(key)); + this.map.removeAll(sanitizeKey(key)); } /** * Removes all contexts from the set. */ public void clear() { - map.clear(); + this.map.clear(); } @Override diff --git a/api/src/main/java/me/lucko/luckperms/api/platform/PlatformType.java b/api/src/main/java/me/lucko/luckperms/api/platform/PlatformType.java index c13545af6..48d8ef3e0 100644 --- a/api/src/main/java/me/lucko/luckperms/api/platform/PlatformType.java +++ b/api/src/main/java/me/lucko/luckperms/api/platform/PlatformType.java @@ -51,6 +51,6 @@ public enum PlatformType { */ @Nonnull public String getFriendlyName() { - return friendlyName; + return this.friendlyName; } } diff --git a/bukkit/pom.xml b/bukkit/pom.xml index 73d81b9e7..8aadaa670 100644 --- a/bukkit/pom.xml +++ b/bukkit/pom.xml @@ -92,11 +92,10 @@ ${project.version} compile - - org.projectlombok - lombok - ${lombok.version} + com.google.code.findbugs + jsr305 + 3.0.2 provided @@ -166,6 +165,16 @@ bukkit-permissions 2.5 provided + + + org.bukkit + bukkit + + + org.mcstats.bukkit + metrics + + diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCommandExecutor.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCommandExecutor.java index 6bc06cc55..99de2c8ca 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCommandExecutor.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitCommandExecutor.java @@ -52,7 +52,7 @@ public class BukkitCommandExecutor extends CommandManager implements CommandExec @Override public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { - Sender lpSender = plugin.getSenderFactory().wrap(sender); + Sender lpSender = this.plugin.getSenderFactory().wrap(sender); List arguments = stripQuotes(ARGUMENT_SPLITTER.splitToList(ARGUMENT_JOINER.join(args))); onCommand(lpSender, label, arguments); @@ -61,7 +61,7 @@ public class BukkitCommandExecutor extends CommandManager implements CommandExec @Override public List onTabComplete(CommandSender sender, Command command, String label, String[] args) { - Sender lpSender = plugin.getSenderFactory().wrap(sender); + Sender lpSender = this.plugin.getSenderFactory().wrap(sender); List arguments = stripQuotes(TAB_COMPLETE_ARGUMENT_SPLITTER.splitToList(ARGUMENT_JOINER.join(args))); return onTabComplete(lpSender, arguments); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitConfigAdapter.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitConfigAdapter.java index bb44b344c..21d6f4286 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitConfigAdapter.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitConfigAdapter.java @@ -52,38 +52,38 @@ public class BukkitConfigAdapter extends AbstractConfigurationAdapter implements @Override public void reload() { - configuration = YamlConfiguration.loadConfiguration(file); + this.configuration = YamlConfiguration.loadConfiguration(this.file); } @Override public boolean contains(String path) { - return configuration.contains(path); + return this.configuration.contains(path); } @Override public String getString(String path, String def) { - return configuration.getString(path, def); + return this.configuration.getString(path, def); } @Override public int getInt(String path, int def) { - return configuration.getInt(path, def); + return this.configuration.getInt(path, def); } @Override public boolean getBoolean(String path, boolean def) { - return configuration.getBoolean(path, def); + return this.configuration.getBoolean(path, def); } @Override public List getList(String path, List def) { - List ret = configuration.getStringList(path); + List ret = this.configuration.getStringList(path); return ret == null ? def : ret; } @Override public List getObjectList(String path, List def) { - ConfigurationSection section = configuration.getConfigurationSection(path); + ConfigurationSection section = this.configuration.getConfigurationSection(path); if (section == null) { return def; } @@ -95,7 +95,7 @@ public class BukkitConfigAdapter extends AbstractConfigurationAdapter implements @Override public Map getMap(String path, Map def) { Map map = new HashMap<>(); - ConfigurationSection section = configuration.getConfigurationSection(path); + ConfigurationSection section = this.configuration.getConfigurationSection(path); if (section == null) { return def; } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSchedulerAdapter.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSchedulerAdapter.java index dcd3b8c12..cd11ef5f0 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSchedulerAdapter.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSchedulerAdapter.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.bukkit; -import lombok.Getter; -import lombok.Setter; -import lombok.experimental.Accessors; - import com.google.common.util.concurrent.ThreadFactoryBuilder; import me.lucko.luckperms.common.plugin.SchedulerAdapter; @@ -43,27 +39,16 @@ import java.util.concurrent.SynchronousQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; +import javax.annotation.Nonnull; + public class BukkitSchedulerAdapter implements SchedulerAdapter { private final LPBukkitPlugin plugin; - @Getter - @Accessors(fluent = true) private final ExecutorService asyncFallback; - - @Getter - @Accessors(fluent = true) private final Executor asyncBukkit; - - @Getter - @Accessors(fluent = true) private final Executor sync; - - @Getter - @Accessors(fluent = true) private final Executor async; - @Getter - @Setter private boolean useFallback = true; private final Set tasks = ConcurrentHashMap.newKeySet(); @@ -89,61 +74,84 @@ public class BukkitSchedulerAdapter implements SchedulerAdapter { @Override public void asyncRepeating(Runnable runnable, long intervalTicks) { - BukkitTask task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, runnable, intervalTicks, intervalTicks); - tasks.add(task); + BukkitTask task = this.plugin.getServer().getScheduler().runTaskTimerAsynchronously(this.plugin, runnable, intervalTicks, intervalTicks); + this.tasks.add(task); } @Override public void syncRepeating(Runnable runnable, long intervalTicks) { - BukkitTask task = plugin.getServer().getScheduler().runTaskTimer(plugin, runnable, intervalTicks, intervalTicks); - tasks.add(task); + BukkitTask task = this.plugin.getServer().getScheduler().runTaskTimer(this.plugin, runnable, intervalTicks, intervalTicks); + this.tasks.add(task); } @Override public void asyncLater(Runnable runnable, long delayTicks) { - plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, runnable, delayTicks); + this.plugin.getServer().getScheduler().runTaskLaterAsynchronously(this.plugin, runnable, delayTicks); } @Override public void syncLater(Runnable runnable, long delayTicks) { - plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, runnable, delayTicks); + this.plugin.getServer().getScheduler().scheduleSyncDelayedTask(this.plugin, runnable, delayTicks); } @Override public void shutdown() { - tasks.forEach(BukkitTask::cancel); + this.tasks.forEach(BukkitTask::cancel); // wait for executor - asyncFallback.shutdown(); + this.asyncFallback.shutdown(); try { - asyncFallback.awaitTermination(30, TimeUnit.SECONDS); + this.asyncFallback.awaitTermination(30, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } + + public ExecutorService asyncFallback() { + return this.asyncFallback; + } + + public Executor asyncBukkit() { + return this.asyncBukkit; + } + + @Override + public Executor sync() { + return this.sync; + } + + @Override + public Executor async() { + return this.async; + } + + public void setUseFallback(boolean useFallback) { + this.useFallback = useFallback; + } + private final class SyncExecutor implements Executor { @Override - public void execute(Runnable runnable) { - plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, runnable); + public void execute(@Nonnull Runnable runnable) { + BukkitSchedulerAdapter.this.plugin.getServer().getScheduler().scheduleSyncDelayedTask(BukkitSchedulerAdapter.this.plugin, runnable); } } private final class AsyncExecutor implements Executor { @Override - public void execute(Runnable runnable) { - if (useFallback || !plugin.isEnabled()) { - asyncFallback.execute(runnable); + public void execute(@Nonnull Runnable runnable) { + if (BukkitSchedulerAdapter.this.useFallback || !BukkitSchedulerAdapter.this.plugin.isEnabled()) { + BukkitSchedulerAdapter.this.asyncFallback.execute(runnable); } else { - asyncBukkit.execute(runnable); + BukkitSchedulerAdapter.this.asyncBukkit.execute(runnable); } } } private final class BukkitAsyncExecutor implements Executor { @Override - public void execute(Runnable runnable) { - plugin.getServer().getScheduler().runTaskAsynchronously(plugin, runnable); + public void execute(@Nonnull Runnable runnable) { + BukkitSchedulerAdapter.this.plugin.getServer().getScheduler().runTaskAsynchronously(BukkitSchedulerAdapter.this.plugin, runnable); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSenderFactory.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSenderFactory.java index ec12b2232..198029925 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSenderFactory.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/BukkitSenderFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.bukkit.compat.BukkitJsonMessageHandler; import me.lucko.luckperms.bukkit.compat.ReflectionUtil; @@ -51,8 +49,8 @@ public class BukkitSenderFactory extends SenderFactory { public BukkitSenderFactory(LuckPermsPlugin plugin) { super(plugin); - bukkitHandler = new BukkitJsonMessageHandler(); - spigotHandler = isSpigot() ? new SpigotJsonMessageHandler() : null; + this.bukkitHandler = new BukkitJsonMessageHandler(); + this.spigotHandler = isSpigot() ? new SpigotJsonMessageHandler() : null; } @Override @@ -89,12 +87,12 @@ public class BukkitSenderFactory extends SenderFactory { String json = ComponentSerializers.JSON.serialize(message); // Try Bukkit. - if (bukkitHandler.sendJsonMessage(player, json)) { + if (this.bukkitHandler.sendJsonMessage(player, json)) { return; } // Try Spigot. - if (spigotHandler != null && spigotHandler.sendJsonMessage(player, json)) { + if (this.spigotHandler != null && this.spigotHandler.sendJsonMessage(player, json)) { return; } } @@ -125,14 +123,18 @@ public class BukkitSenderFactory extends SenderFactory { } } - @AllArgsConstructor private static final class BlockMessengerAgent implements Runnable { private final BlockCommandSender block; private final String message; + private BlockMessengerAgent(BlockCommandSender block, String message) { + this.block = block; + this.message = message; + } + @Override public void run() { - block.sendMessage(message); + this.block.sendMessage(this.message); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java index b1084154d..95e2d8545 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/LPBukkitPlugin.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit; -import lombok.Getter; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.LuckPermsApi; import me.lucko.luckperms.api.platform.PlatformType; @@ -110,7 +108,6 @@ import java.util.stream.Stream; /** * LuckPerms implementation for the Bukkit API. */ -@Getter public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { private long startTime; @@ -150,13 +147,13 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { } // setup minimal functionality in order to load initial dependencies - scheduler = new BukkitSchedulerAdapter(this); - localeManager = new NoopLocaleManager(); - senderFactory = new BukkitSenderFactory(this); - log = new SenderLogger(this, getConsoleSender()); + this.scheduler = new BukkitSchedulerAdapter(this); + this.localeManager = new NoopLocaleManager(); + this.senderFactory = new BukkitSenderFactory(this); + this.log = new SenderLogger(this, getConsoleSender()); - dependencyManager = new DependencyManager(this); - dependencyManager.loadDependencies(Collections.singleton(Dependency.CAFFEINE)); + this.dependencyManager = new DependencyManager(this); + this.dependencyManager.loadDependencies(Collections.singleton(Dependency.CAFFEINE)); } @Override @@ -178,103 +175,103 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { } finally { // count down the latch when onEnable has been called // we don't care about the result here - enableLatch.countDown(); + this.enableLatch.countDown(); } } private void enable() { - startTime = System.currentTimeMillis(); + this.startTime = System.currentTimeMillis(); sendStartupBanner(getConsoleSender()); - verboseHandler = new VerboseHandler(scheduler.asyncBukkit(), getVersion()); - permissionVault = new PermissionVault(scheduler.asyncBukkit()); - logDispatcher = new LogDispatcher(this); + this.verboseHandler = new VerboseHandler(this.scheduler.asyncBukkit(), getVersion()); + this.permissionVault = new PermissionVault(this.scheduler.asyncBukkit()); + this.logDispatcher = new LogDispatcher(this); getLog().info("Loading configuration..."); - configuration = new AbstractConfiguration(this, new BukkitConfigAdapter(this, resolveConfig("config.yml"))); - configuration.loadAll(); + this.configuration = new AbstractConfiguration(this, new BukkitConfigAdapter(this, resolveConfig("config.yml"))); + this.configuration.loadAll(); StorageFactory storageFactory = new StorageFactory(this); Set storageTypes = storageFactory.getRequiredTypes(StorageType.H2); - dependencyManager.loadStorageDependencies(storageTypes); + this.dependencyManager.loadStorageDependencies(storageTypes); // setup the Bukkit defaults hook - defaultsProvider = new DefaultsProvider(); - childPermissionProvider = new ChildPermissionProvider(); + this.defaultsProvider = new DefaultsProvider(); + this.childPermissionProvider = new ChildPermissionProvider(); // give all plugins a chance to load their permissions, then refresh. - scheduler.syncLater(new BukkitProcessorsSetupTask(this), 1L); + this.scheduler.syncLater(new BukkitProcessorsSetupTask(this), 1L); // register events getServer().getPluginManager().registerEvents(new BukkitConnectionListener(this), this); getServer().getPluginManager().registerEvents(new BukkitPlatformListener(this), this); if (getConfiguration().get(ConfigKeys.WATCH_FILES)) { - fileWatcher = new FileWatcher(this); - getScheduler().asyncRepeating(fileWatcher, 30L); + this.fileWatcher = new FileWatcher(this); + getScheduler().asyncRepeating(this.fileWatcher, 30L); } // initialise datastore - storage = storageFactory.getInstance(StorageType.H2); + this.storage = storageFactory.getInstance(StorageType.H2); // initialise messaging - messagingService = new BukkitMessagingFactory(this).getInstance(); + this.messagingService = new BukkitMessagingFactory(this).getInstance(); // setup the update task buffer - updateTaskBuffer = new UpdateTaskBuffer(this); + this.updateTaskBuffer = new UpdateTaskBuffer(this); // load locale - localeManager = new SimpleLocaleManager(); - localeManager.tryLoad(this, new File(getDataFolder(), "lang.yml")); + this.localeManager = new SimpleLocaleManager(); + this.localeManager.tryLoad(this, new File(getDataFolder(), "lang.yml")); // register commands - commandManager = new BukkitCommandExecutor(this); + this.commandManager = new BukkitCommandExecutor(this); PluginCommand main = getServer().getPluginCommand("luckperms"); - main.setExecutor(commandManager); - main.setTabCompleter(commandManager); + main.setExecutor(this.commandManager); + main.setTabCompleter(this.commandManager); main.setDescription("Manage permissions"); main.setAliases(Arrays.asList("lp", "perm", "perms", "permission", "permissions")); // load internal managers getLog().info("Loading internal permission managers..."); - uuidCache = new UuidCache(this); - userManager = new GenericUserManager(this); - groupManager = new GenericGroupManager(this); - trackManager = new GenericTrackManager(this); - calculatorFactory = new BukkitCalculatorFactory(this); - cachedStateManager = new CachedStateManager(); + this.uuidCache = new UuidCache(this); + this.userManager = new GenericUserManager(this); + this.groupManager = new GenericGroupManager(this); + this.trackManager = new GenericTrackManager(this); + this.calculatorFactory = new BukkitCalculatorFactory(this); + this.cachedStateManager = new CachedStateManager(); // setup context manager - contextManager = new BukkitContextManager(this); - contextManager.registerCalculator(new WorldCalculator(this)); - contextManager.registerStaticCalculator(new LuckPermsCalculator(getConfiguration())); + this.contextManager = new BukkitContextManager(this); + this.contextManager.registerCalculator(new WorldCalculator(this)); + this.contextManager.registerStaticCalculator(new LuckPermsCalculator(getConfiguration())); // inject our own subscription map new SubscriptionMapInjector(this).run(); // schedule another injection after all plugins have loaded - the entire pluginmanager instance // is replaced by some plugins :( - scheduler.asyncLater(new SubscriptionMapInjector(this), 2L); + this.scheduler.asyncLater(new SubscriptionMapInjector(this), 2L); // Provide vault support tryVaultHook(false); // register with the LP API - apiProvider = new LuckPermsApiProvider(this); + this.apiProvider = new LuckPermsApiProvider(this); // setup event factory - eventFactory = new EventFactory(this, apiProvider); + this.eventFactory = new EventFactory(this, this.apiProvider); - ApiRegistrationUtil.registerProvider(apiProvider); - getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal); + ApiRegistrationUtil.registerProvider(this.apiProvider); + getServer().getServicesManager().register(LuckPermsApi.class, this.apiProvider, this, ServicePriority.Normal); // schedule update tasks int mins = getConfiguration().get(ConfigKeys.SYNC_TIME); if (mins > 0) { long ticks = mins * 60 * 20; - scheduler.asyncRepeating(() -> updateTaskBuffer.request(), ticks); + this.scheduler.asyncRepeating(() -> this.updateTaskBuffer.request(), ticks); } - scheduler.asyncLater(() -> updateTaskBuffer.request(), 40L); + this.scheduler.asyncLater(() -> this.updateTaskBuffer.request(), 40L); // run an update instantly. getLog().info("Performing initial data load..."); @@ -286,8 +283,8 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { // register tasks - scheduler.asyncRepeating(new ExpireTemporaryTask(this), 60L); - scheduler.asyncRepeating(new CacheHousekeepingTask(this), 2400L); + this.scheduler.asyncRepeating(new ExpireTemporaryTask(this), 60L); + this.scheduler.asyncRepeating(new CacheHousekeepingTask(this), 2400L); // register permissions try { @@ -302,20 +299,20 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { } if (!getConfiguration().get(ConfigKeys.OPS_ENABLED)) { - scheduler.doSync(() -> getServer().getOperators().forEach(o -> o.setOp(false))); + this.scheduler.doSync(() -> getServer().getOperators().forEach(o -> o.setOp(false))); } // replace the temporary executor when the Bukkit one starts - getServer().getScheduler().runTaskAsynchronously(this, () -> scheduler.setUseFallback(false)); + getServer().getScheduler().runTaskAsynchronously(this, () -> this.scheduler.setUseFallback(false)); // Load any online users (in the case of a reload) for (Player player : getServer().getOnlinePlayers()) { - scheduler.doAsync(() -> { + this.scheduler.doAsync(() -> { try { LoginHelper.loadUser(this, player.getUniqueId(), player.getName(), false); User user = getUserManager().getIfLoaded(getUuidCache().getUUID(player.getUniqueId())); if (user != null) { - scheduler.doSync(() -> { + this.scheduler.doSync(() -> { try { LPPermissible lpPermissible = new LPPermissible(player, user, this); PermissibleInjector.inject(player, lpPermissible); @@ -330,7 +327,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { }); } - getLog().info("Successfully enabled. (took " + (System.currentTimeMillis() - startTime) + "ms)"); + getLog().info("Successfully enabled. (took " + (System.currentTimeMillis() - this.startTime) + "ms)"); } @Override @@ -340,11 +337,11 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { } // Switch back to the fallback executor, the bukkit one won't allow new tasks - scheduler.setUseFallback(true); + this.scheduler.setUseFallback(true); - defaultsProvider.close(); - permissionVault.shutdown(); - verboseHandler.shutdown(); + this.defaultsProvider.close(); + this.permissionVault.shutdown(); + this.verboseHandler.shutdown(); // uninject from players for (Player player : getServer().getOnlinePlayers()) { @@ -369,26 +366,26 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { SubscriptionMapInjector.uninject(); getLog().info("Closing storage..."); - storage.shutdown(); + this.storage.shutdown(); - if (fileWatcher != null) { - fileWatcher.close(); + if (this.fileWatcher != null) { + this.fileWatcher.close(); } - if (messagingService != null) { + if (this.messagingService != null) { getLog().info("Closing messaging service..."); - messagingService.close(); + this.messagingService.close(); } ApiRegistrationUtil.unregisterProvider(); getServer().getServicesManager().unregisterAll(this); - if (vaultHookManager != null) { - vaultHookManager.unhook(this); + if (this.vaultHookManager != null) { + this.vaultHookManager.unhook(this); } getLog().info("Shutting down internal scheduler..."); - scheduler.shutdown(); + this.scheduler.shutdown(); // Bukkit will do this again when #onDisable completes, but we do it early to prevent NPEs elsewhere. getServer().getScheduler().cancelTasks(this); @@ -397,18 +394,18 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { } public void tryVaultHook(boolean force) { - if (vaultHookManager != null) { + if (this.vaultHookManager != null) { return; // already hooked } try { if (force || getServer().getPluginManager().isPluginEnabled("Vault")) { - vaultHookManager = new VaultHookManager(); - vaultHookManager.hook(this); + this.vaultHookManager = new VaultHookManager(); + this.vaultHookManager.hook(this); getLog().info("Registered Vault permission & chat hook."); } } catch (Exception e) { - vaultHookManager = null; + this.vaultHookManager = null; getLog().severe("Error occurred whilst hooking into Vault."); e.printStackTrace(); } @@ -420,7 +417,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { } if (getConfiguration().get(ConfigKeys.AUTO_OP)) { - Map backing = user.getCachedData().getPermissionData(contextManager.getApplicableContexts(player)).getImmutableBacking(); + Map backing = user.getCachedData().getPermissionData(this.contextManager.getApplicableContexts(player)).getImmutableBacking(); boolean op = Optional.ofNullable(backing.get("luckperms.autoop")).orElse(false); player.setOp(op); } @@ -439,11 +436,12 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { @Override public Optional getMessagingService() { - return Optional.ofNullable(messagingService); + return Optional.ofNullable(this.messagingService); } + @Override public Optional getFileWatcher() { - return Optional.ofNullable(fileWatcher); + return Optional.ofNullable(this.fileWatcher); } @Override @@ -483,7 +481,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { @Override public Player getPlayer(User user) { - return getServer().getPlayer(uuidCache.getExternalUUID(user.getUuid())); + return getServer().getPlayer(this.uuidCache.getExternalUUID(user.getUuid())); } @Override @@ -503,7 +501,7 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { if (player == null) { return null; } - return contextManager.getApplicableContexts(player); + return this.contextManager.getApplicableContexts(player); } @Override @@ -543,9 +541,9 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { @Override public Map getExtraInfo() { Map map = new LinkedHashMap<>(); - map.put("Vault Enabled", vaultHookManager != null); - map.put("Bukkit Defaults count", defaultsProvider.size()); - map.put("Bukkit Child Permissions count", childPermissionProvider.getPermissions().size()); + map.put("Vault Enabled", this.vaultHookManager != null); + map.put("Bukkit Defaults count", this.defaultsProvider.size()); + map.put("Bukkit Child Permissions count", this.childPermissionProvider.getPermissions().size()); return map; } @@ -557,4 +555,134 @@ public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin { return true; } } + + @Override + public long getStartTime() { + return this.startTime; + } + + @Override + public BukkitSchedulerAdapter getScheduler() { + return this.scheduler; + } + + @Override + public BukkitCommandExecutor getCommandManager() { + return this.commandManager; + } + + public VaultHookManager getVaultHookManager() { + return this.vaultHookManager; + } + + @Override + public LuckPermsConfiguration getConfiguration() { + return this.configuration; + } + + @Override + public UserManager getUserManager() { + return this.userManager; + } + + @Override + public GroupManager getGroupManager() { + return this.groupManager; + } + + @Override + public TrackManager getTrackManager() { + return this.trackManager; + } + + @Override + public Storage getStorage() { + return this.storage; + } + + @Override + public UuidCache getUuidCache() { + return this.uuidCache; + } + + @Override + public LuckPermsApiProvider getApiProvider() { + return this.apiProvider; + } + + @Override + public EventFactory getEventFactory() { + return this.eventFactory; + } + + @Override + public Logger getLog() { + return this.log; + } + + public DefaultsProvider getDefaultsProvider() { + return this.defaultsProvider; + } + + public ChildPermissionProvider getChildPermissionProvider() { + return this.childPermissionProvider; + } + + @Override + public LocaleManager getLocaleManager() { + return this.localeManager; + } + + @Override + public DependencyManager getDependencyManager() { + return this.dependencyManager; + } + + @Override + public CachedStateManager getCachedStateManager() { + return this.cachedStateManager; + } + + @Override + public ContextManager getContextManager() { + return this.contextManager; + } + + @Override + public CalculatorFactory getCalculatorFactory() { + return this.calculatorFactory; + } + + @Override + public BufferedRequest getUpdateTaskBuffer() { + return this.updateTaskBuffer; + } + + public CountDownLatch getEnableLatch() { + return this.enableLatch; + } + + @Override + public VerboseHandler getVerboseHandler() { + return this.verboseHandler; + } + + public BukkitSenderFactory getSenderFactory() { + return this.senderFactory; + } + + @Override + public PermissionVault getPermissionVault() { + return this.permissionVault; + } + + @Override + public LogDispatcher getLogDispatcher() { + return this.logDispatcher; + } + + @Override + public Set getUniqueConnections() { + return this.uniqueConnections; + } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/BukkitCalculatorFactory.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/BukkitCalculatorFactory.java index c259bdc01..98c6ddb45 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/BukkitCalculatorFactory.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/calculators/BukkitCalculatorFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.calculators; -import lombok.AllArgsConstructor; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.Contexts; @@ -45,44 +43,47 @@ import me.lucko.luckperms.common.references.HolderType; import java.util.List; -@AllArgsConstructor public class BukkitCalculatorFactory extends AbstractCalculatorFactory { private final LPBukkitPlugin plugin; + public BukkitCalculatorFactory(LPBukkitPlugin plugin) { + this.plugin = plugin; + } + @Override public PermissionCalculator build(Contexts contexts, PermissionCalculatorMetadata metadata) { ImmutableList.Builder processors = ImmutableList.builder(); processors.add(new MapProcessor()); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_CHILD_PERMISSIONS)) { - processors.add(new ChildProcessor(plugin.getChildPermissionProvider())); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_CHILD_PERMISSIONS)) { + processors.add(new ChildProcessor(this.plugin.getChildPermissionProvider())); } - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { processors.add(new RegexProcessor()); } - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { processors.add(new WildcardProcessor()); } - if (plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS) && metadata.getHolderType() == HolderType.USER) { - processors.add(new DefaultsProcessor(contexts.isOp(), plugin.getDefaultsProvider())); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS) && metadata.getHolderType() == HolderType.USER) { + processors.add(new DefaultsProcessor(contexts.isOp(), this.plugin.getDefaultsProvider())); } - return registerCalculator(new PermissionCalculator(plugin, metadata, processors.build())); + return registerCalculator(new PermissionCalculator(this.plugin, metadata, processors.build())); } @Override public List getActiveProcessors() { ImmutableList.Builder ret = ImmutableList.builder(); ret.add("Map"); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_CHILD_PERMISSIONS)) ret.add("Child"); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_ATTACHMENT_PERMISSIONS)) ret.add("Attachment"); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) ret.add("Regex"); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) ret.add("Wildcard"); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) ret.add("Defaults"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_CHILD_PERMISSIONS)) ret.add("Child"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_ATTACHMENT_PERMISSIONS)) ret.add("Attachment"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) ret.add("Regex"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) ret.add("Wildcard"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) ret.add("Defaults"); return ret.build(); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/compat/ReflectionUtil.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/compat/ReflectionUtil.java index 149cd9736..18d0e84eb 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/compat/ReflectionUtil.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/compat/ReflectionUtil.java @@ -25,12 +25,9 @@ package me.lucko.luckperms.bukkit.compat; -import lombok.experimental.UtilityClass; - import org.bukkit.Bukkit; -@UtilityClass -public class ReflectionUtil { +public final class ReflectionUtil { private static final String SERVER_VERSION = _getServerVersion(); private static final boolean CHAT_COMPATIBLE = !SERVER_VERSION.startsWith(".v1_7_"); @@ -71,4 +68,7 @@ public class ReflectionUtil { public static Class obcClass(String className) throws ClassNotFoundException { return Class.forName(obc(className)); } + + private ReflectionUtil() {} + } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/BukkitContextManager.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/BukkitContextManager.java index d34d12ada..151ea48d4 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/BukkitContextManager.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/BukkitContextManager.java @@ -42,11 +42,11 @@ public class BukkitContextManager extends AbstractContextManager { public Contexts formContexts(Player subject, ImmutableContextSet contextSet) { return new Contexts( contextSet, - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), true, - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), subject.isOp() ); } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/WorldCalculator.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/WorldCalculator.java index 5c952dc67..e7b763924 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/WorldCalculator.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/contexts/WorldCalculator.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.contexts; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.context.ContextCalculator; import me.lucko.luckperms.api.context.MutableContextSet; @@ -35,16 +33,22 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import org.bukkit.entity.Player; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class WorldCalculator implements ContextCalculator { private final LuckPermsPlugin plugin; + public WorldCalculator(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + @Nonnull @Override - public MutableContextSet giveApplicableContext(Player subject, MutableContextSet accumulator) { + public MutableContextSet giveApplicableContext(@Nonnull Player subject, @Nonnull MutableContextSet accumulator) { String world = subject.getWorld().getName().toLowerCase(); while (!accumulator.has(Contexts.WORLD_KEY, world)) { accumulator.add(Contexts.WORLD_KEY, world); - world = plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world).toLowerCase(); + world = this.plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world).toLowerCase(); } return accumulator; diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitConnectionListener.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitConnectionListener.java index 7fa89add2..8d26f023f 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitConnectionListener.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitConnectionListener.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.listeners; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.bukkit.LPBukkitPlugin; import me.lucko.luckperms.bukkit.model.LPPermissible; import me.lucko.luckperms.bukkit.model.PermissibleInjector; @@ -49,13 +47,16 @@ import java.util.Set; import java.util.UUID; import java.util.concurrent.TimeUnit; -@RequiredArgsConstructor public class BukkitConnectionListener implements Listener { private final LPBukkitPlugin plugin; private final Set deniedAsyncLogin = Collections.synchronizedSet(new HashSet<>()); private final Set deniedLogin = Collections.synchronizedSet(new HashSet<>()); + public BukkitConnectionListener(LPBukkitPlugin plugin) { + this.plugin = plugin; + } + @EventHandler(priority = EventPriority.LOW) public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) { /* Called when the player first attempts a connection with the server. @@ -64,16 +65,16 @@ public class BukkitConnectionListener implements Listener { /* wait for the plugin to enable. because these events are fired async, they can be called before the plugin has enabled. */ try { - plugin.getEnableLatch().await(60, TimeUnit.SECONDS); + this.plugin.getEnableLatch().await(60, TimeUnit.SECONDS); } catch (InterruptedException ex) { ex.printStackTrace(); } - if (plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { - plugin.getLog().info("Processing pre-login for " + e.getUniqueId() + " - " + e.getName()); + if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { + this.plugin.getLog().info("Processing pre-login for " + e.getUniqueId() + " - " + e.getName()); } - plugin.getUniqueConnections().add(e.getUniqueId()); + this.plugin.getUniqueConnections().add(e.getUniqueId()); /* Actually process the login for the connection. We do this here to delay the login until the data is ready. @@ -85,15 +86,15 @@ public class BukkitConnectionListener implements Listener { - creating a user instance in the UserManager for this connection. - setting up cached data. */ try { - User user = LoginHelper.loadUser(plugin, e.getUniqueId(), e.getName(), false); - plugin.getEventFactory().handleUserLoginProcess(e.getUniqueId(), e.getName(), user); + User user = LoginHelper.loadUser(this.plugin, e.getUniqueId(), e.getName(), false); + this.plugin.getEventFactory().handleUserLoginProcess(e.getUniqueId(), e.getName(), user); } catch (Exception ex) { - plugin.getLog().severe("Exception occured whilst loading data for " + e.getUniqueId() + " - " + e.getName()); + this.plugin.getLog().severe("Exception occured whilst loading data for " + e.getUniqueId() + " - " + e.getName()); ex.printStackTrace(); // deny the connection - deniedAsyncLogin.add(e.getUniqueId()); - e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.asString(plugin.getLocaleManager())); + this.deniedAsyncLogin.add(e.getUniqueId()); + e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.asString(this.plugin.getLocaleManager())); } } @@ -103,12 +104,12 @@ public class BukkitConnectionListener implements Listener { If the connection was cancelled here, we need to do something to clean up the data that was loaded. */ // Check to see if this connection was denied at LOW. - if (deniedAsyncLogin.remove(e.getUniqueId())) { + if (this.deniedAsyncLogin.remove(e.getUniqueId())) { // their data was never loaded at LOW priority, now check to see if they have been magically allowed since then. // This is a problem, as they were denied at low priority, but are now being allowed. if (e.getLoginResult() == AsyncPlayerPreLoginEvent.Result.ALLOWED) { - plugin.getLog().severe("Player connection was re-allowed for " + e.getUniqueId()); + this.plugin.getLog().severe("Player connection was re-allowed for " + e.getUniqueId()); e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, ""); } @@ -118,7 +119,7 @@ public class BukkitConnectionListener implements Listener { // Login event was cancelled by another plugin, but it wasn't cancelled when we handled it at LOW if (e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) { // Schedule cleanup of this user. - plugin.getUserManager().scheduleUnload(e.getUniqueId()); + this.plugin.getUserManager().scheduleUnload(e.getUniqueId()); } } @@ -129,18 +130,18 @@ public class BukkitConnectionListener implements Listener { final Player player = e.getPlayer(); - if (plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { - plugin.getLog().info("Processing login for " + player.getUniqueId() + " - " + player.getName()); + if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { + this.plugin.getLog().info("Processing login for " + player.getUniqueId() + " - " + player.getName()); } - final User user = plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(player.getUniqueId())); + final User user = this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(player.getUniqueId())); /* User instance is null for whatever reason. Could be that it was unloaded between asyncpre and now. */ if (user == null) { - deniedLogin.add(e.getPlayer().getUniqueId()); + this.deniedLogin.add(e.getPlayer().getUniqueId()); - plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded. - denying login."); - e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.asString(plugin.getLocaleManager())); + this.plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded. - denying login."); + e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.asString(this.plugin.getLocaleManager())); return; } @@ -148,7 +149,7 @@ public class BukkitConnectionListener implements Listener { // Care should be taken at this stage to ensure that async tasks which manipulate bukkit data check that the player is still online. try { // Make a new permissible for the user - LPPermissible lpPermissible = new LPPermissible(player, user, plugin); + LPPermissible lpPermissible = new LPPermissible(player, user, this.plugin); // Inject into the player PermissibleInjector.inject(player, lpPermissible); @@ -157,7 +158,7 @@ public class BukkitConnectionListener implements Listener { t.printStackTrace(); } - plugin.refreshAutoOp(user, player); + this.plugin.refreshAutoOp(user, player); } @EventHandler(priority = EventPriority.MONITOR) @@ -167,12 +168,12 @@ public class BukkitConnectionListener implements Listener { // Check to see if this connection was denied at LOW. Even if it was denied at LOW, their data will still be present. boolean denied = false; - if (deniedLogin.remove(e.getPlayer().getUniqueId())) { + if (this.deniedLogin.remove(e.getPlayer().getUniqueId())) { denied = true; // This is a problem, as they were denied at low priority, but are now being allowed. if (e.getResult() == PlayerLoginEvent.Result.ALLOWED) { - plugin.getLog().severe("Player connection was re-allowed for " + e.getPlayer().getUniqueId()); + this.plugin.getLog().severe("Player connection was re-allowed for " + e.getPlayer().getUniqueId()); e.disallow(PlayerLoginEvent.Result.KICK_OTHER, ""); } } @@ -180,12 +181,12 @@ public class BukkitConnectionListener implements Listener { // Login event was cancelled by another plugin since we first loaded their data if (denied || e.getResult() != PlayerLoginEvent.Result.ALLOWED) { // Schedule cleanup of this user. - plugin.getUserManager().scheduleUnload(e.getPlayer().getUniqueId()); + this.plugin.getUserManager().scheduleUnload(e.getPlayer().getUniqueId()); return; } // everything is going well. login was processed ok, this is just to refresh auto-op status. - plugin.refreshAutoOp(plugin.getUserManager().getIfLoaded(e.getPlayer().getUniqueId()), e.getPlayer()); + this.plugin.refreshAutoOp(this.plugin.getUserManager().getIfLoaded(e.getPlayer().getUniqueId()), e.getPlayer()); } // Wait until the last priority to unload, so plugins can still perform permission checks on this event @@ -201,12 +202,12 @@ public class BukkitConnectionListener implements Listener { } // Handle auto op - if (plugin.getConfiguration().get(ConfigKeys.AUTO_OP)) { + if (this.plugin.getConfiguration().get(ConfigKeys.AUTO_OP)) { player.setOp(false); } // Request that the users data is unloaded. - plugin.getUserManager().scheduleUnload(player.getUniqueId()); + this.plugin.getUserManager().scheduleUnload(player.getUniqueId()); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitPlatformListener.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitPlatformListener.java index 225ee61fb..cd67c0567 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitPlatformListener.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/listeners/BukkitPlatformListener.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.listeners; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.bukkit.LPBukkitPlugin; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.locale.Message; @@ -42,10 +40,13 @@ import org.bukkit.event.server.PluginEnableEvent; import org.bukkit.event.server.RemoteServerCommandEvent; import org.bukkit.event.server.ServerCommandEvent; -@RequiredArgsConstructor public class BukkitPlatformListener implements Listener { private final LPBukkitPlugin plugin; + public BukkitPlatformListener(LPBukkitPlugin plugin) { + this.plugin = plugin; + } + @EventHandler public void onPlayerCommand(PlayerCommandPreprocessEvent e) { handleCommand(e.getPlayer(), e.getMessage().toLowerCase(), e); @@ -66,7 +67,7 @@ public class BukkitPlatformListener implements Listener { return; } - if (plugin.getConfiguration().get(ConfigKeys.OPS_ENABLED)) { + if (this.plugin.getConfiguration().get(ConfigKeys.OPS_ENABLED)) { return; } @@ -80,21 +81,21 @@ public class BukkitPlatformListener implements Listener { if (s.equals("op") || s.startsWith("op ") || s.equals("deop") || s.startsWith("deop ")) { event.setCancelled(true); - sender.sendMessage(Message.OP_DISABLED.asString(plugin.getLocaleManager())); + sender.sendMessage(Message.OP_DISABLED.asString(this.plugin.getLocaleManager())); } } @EventHandler public void onPluginEnable(PluginEnableEvent e) { if (e.getPlugin().getName().equalsIgnoreCase("Vault")) { - plugin.tryVaultHook(true); + this.plugin.tryVaultHook(true); } } @EventHandler(priority = EventPriority.LOWEST) public void onWorldChange(PlayerChangedWorldEvent e) { - plugin.getContextManager().invalidateCache(e.getPlayer()); - plugin.refreshAutoOp(plugin.getUserManager().getIfLoaded(e.getPlayer().getUniqueId()), e.getPlayer()); + this.plugin.getContextManager().invalidateCache(e.getPlayer()); + this.plugin.refreshAutoOp(this.plugin.getUserManager().getIfLoaded(e.getPlayer().getUniqueId()), e.getPlayer()); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/BungeeMessagingService.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/BungeeMessagingService.java index 667efe933..54a90477a 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/BungeeMessagingService.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/BungeeMessagingService.java @@ -52,14 +52,14 @@ public class BungeeMessagingService extends AbstractMessagingService implements } public void init() { - plugin.getServer().getMessenger().registerOutgoingPluginChannel(plugin, CHANNEL); - plugin.getServer().getMessenger().registerIncomingPluginChannel(plugin, CHANNEL, this); + this.plugin.getServer().getMessenger().registerOutgoingPluginChannel(this.plugin, CHANNEL); + this.plugin.getServer().getMessenger().registerIncomingPluginChannel(this.plugin, CHANNEL, this); } @Override public void close() { - plugin.getServer().getMessenger().unregisterIncomingPluginChannel(plugin, CHANNEL); - plugin.getServer().getMessenger().unregisterOutgoingPluginChannel(plugin, CHANNEL); + this.plugin.getServer().getMessenger().unregisterIncomingPluginChannel(this.plugin, CHANNEL); + this.plugin.getServer().getMessenger().unregisterOutgoingPluginChannel(this.plugin, CHANNEL); } @Override @@ -67,7 +67,7 @@ public class BungeeMessagingService extends AbstractMessagingService implements new BukkitRunnable() { @Override public void run() { - Collection players = plugin.getServer().getOnlinePlayers(); + Collection players = BungeeMessagingService.this.plugin.getServer().getOnlinePlayers(); Player p = Iterables.getFirst(players, null); if (p == null) { return; @@ -78,10 +78,10 @@ public class BungeeMessagingService extends AbstractMessagingService implements byte[] data = out.toByteArray(); - p.sendPluginMessage(plugin, CHANNEL, data); + p.sendPluginMessage(BungeeMessagingService.this.plugin, CHANNEL, data); cancel(); } - }.runTaskTimer(plugin, 1L, 100L); + }.runTaskTimer(this.plugin, 1L, 100L); } @Override diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/LilyPadMessagingService.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/LilyPadMessagingService.java index a3571938d..d6702965d 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/LilyPadMessagingService.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/messaging/LilyPadMessagingService.java @@ -51,13 +51,13 @@ public class LilyPadMessagingService extends AbstractMessagingService { } public void init() { - connect = plugin.getServer().getServicesManager().getRegistration(Connect.class).getProvider(); - connect.registerEvents(this); + this.connect = this.plugin.getServer().getServicesManager().getRegistration(Connect.class).getProvider(); + this.connect.registerEvents(this); } @Override public void close() { - connect.unregisterEvents(this); + this.connect.unregisterEvents(this); } @Override @@ -72,7 +72,7 @@ public class LilyPadMessagingService extends AbstractMessagingService { } try { - connect.request(request); + this.connect.request(request); } catch (RequestException e) { e.printStackTrace(); } @@ -80,7 +80,7 @@ public class LilyPadMessagingService extends AbstractMessagingService { @EventListener public void onMessage(MessageEvent event) { - plugin.getScheduler().doAsync(() -> { + this.plugin.getScheduler().doAsync(() -> { try { String channel = event.getChannel(); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/BukkitMigrationUtils.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/BukkitMigrationUtils.java index 96e6bb168..8e98fc50d 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/BukkitMigrationUtils.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/BukkitMigrationUtils.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.migration; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.common.commands.utils.CommandUtils; import me.lucko.luckperms.common.logging.ProgressLogger; @@ -34,8 +32,7 @@ import org.bukkit.Bukkit; import java.util.UUID; -@UtilityClass -public class BukkitMigrationUtils { +public final class BukkitMigrationUtils { @SuppressWarnings("deprecation") public static UUID lookupUuid(ProgressLogger log, String s) { @@ -53,4 +50,6 @@ public class BukkitMigrationUtils { return uuid; } + private BukkitMigrationUtils() {} + } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationBPermissions.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationBPermissions.java index 1ac5e536a..fce571ab6 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationBPermissions.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationBPermissions.java @@ -34,7 +34,6 @@ import de.bananaco.bpermissions.api.WorldManager; import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; import me.lucko.luckperms.common.commands.impl.migration.MigrationUtils; @@ -77,7 +76,7 @@ public class MigrationBPermissions extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("bPermissions"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationGroupManager.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationGroupManager.java index a521a772c..c636140db 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationGroupManager.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationGroupManager.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.bukkit.migration; import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -65,7 +64,7 @@ public class MigrationGroupManager extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("GroupManager"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsBukkit.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsBukkit.java index d4719b28f..2cee395ce 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsBukkit.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsBukkit.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.bukkit.migration; import com.platymuus.bukkit.permissions.PermissionsPlugin; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -59,7 +58,7 @@ public class MigrationPermissionsBukkit extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("PermissionsBukkit"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsEx.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsEx.java index 1bb534f10..97a230e5c 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsEx.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsEx.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.bukkit.migration; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -67,7 +66,7 @@ public class MigrationPermissionsEx extends SubCommand { @SuppressWarnings("deprecation") @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("PermissionsEx"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPowerfulPerms.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPowerfulPerms.java index c0f7ee15b..4bfaa5a66 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPowerfulPerms.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPowerfulPerms.java @@ -34,7 +34,6 @@ import com.google.common.collect.ImmutableSet; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; import me.lucko.luckperms.common.commands.impl.migration.MigrationUtils; @@ -77,7 +76,7 @@ public class MigrationPowerfulPerms extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("PowerfulPerms"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationZPermissions.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationZPermissions.java index 21cf92719..23bcdddb9 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationZPermissions.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationZPermissions.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.bukkit.migration; import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -69,7 +68,7 @@ public class MigrationZPermissions extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("zPermissions"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/DummyPermissible.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/DummyPermissible.java index 9b03efe71..fb1f47259 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/DummyPermissible.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/DummyPermissible.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.model; -import lombok.AllArgsConstructor; - import org.bukkit.permissions.Permissible; import org.bukkit.permissions.Permission; import org.bukkit.permissions.PermissionAttachment; @@ -36,13 +34,16 @@ import org.bukkit.plugin.Plugin; import java.util.Collections; import java.util.Set; -@AllArgsConstructor public class DummyPermissible implements Permissible { private final Runnable onRefresh; + public DummyPermissible(Runnable onRefresh) { + this.onRefresh = onRefresh; + } + @Override public void recalculatePermissions() { - onRefresh.run(); + this.onRefresh.run(); } @Override public Set getEffectivePermissions() { return Collections.emptySet(); } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissible.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissible.java index 9c507651a..29c36bf14 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissible.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissible.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.bukkit.model; -import lombok.Getter; -import lombok.NonNull; -import lombok.Setter; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.bukkit.LPBukkitPlugin; @@ -46,6 +42,7 @@ import org.bukkit.plugin.Plugin; import java.util.Collection; import java.util.HashSet; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicBoolean; @@ -64,7 +61,6 @@ import java.util.concurrent.atomic.AtomicBoolean; * This class is **thread safe**. This means that when LuckPerms is installed on the server, * is is safe to call Player#hasPermission asynchronously. */ -@Getter public class LPPermissible extends PermissibleBase { // the LuckPerms user this permissible references. @@ -77,7 +73,6 @@ public class LPPermissible extends PermissibleBase { private final LPBukkitPlugin plugin; // the players previous permissible. (the one they had before this one was injected) - @Setter private PermissibleBase oldPermissible = null; // if the permissible is currently active. @@ -87,27 +82,35 @@ public class LPPermissible extends PermissibleBase { // this collection is only modified by the attachments themselves final Set attachments = ConcurrentHashMap.newKeySet(); - public LPPermissible(@NonNull Player player, @NonNull User user, @NonNull LPBukkitPlugin plugin) { + public LPPermissible(Player player, User user, LPBukkitPlugin plugin) { super(player); - this.user = user; - this.player = player; - this.plugin = plugin; + this.user = Objects.requireNonNull(user, "user"); + this.player = Objects.requireNonNull(player, "player"); + this.plugin = Objects.requireNonNull(plugin, "plugin"); } @Override - public boolean isPermissionSet(@NonNull String permission) { - Tristate ts = user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission, CheckOrigin.PLATFORM_LOOKUP_CHECK); + public boolean isPermissionSet(String permission) { + if (permission == null) { + throw new NullPointerException("permission"); + } + + Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission, CheckOrigin.PLATFORM_LOOKUP_CHECK); return ts != Tristate.UNDEFINED || Permission.DEFAULT_PERMISSION.getValue(isOp()); } @Override - public boolean isPermissionSet(@NonNull Permission permission) { - Tristate ts = user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission.getName(), CheckOrigin.PLATFORM_LOOKUP_CHECK); + public boolean isPermissionSet(Permission permission) { + if (permission == null) { + throw new NullPointerException("permission"); + } + + Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission.getName(), CheckOrigin.PLATFORM_LOOKUP_CHECK); if (ts != Tristate.UNDEFINED) { return true; } - if (!plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) { + if (!this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) { return Permission.DEFAULT_PERMISSION.getValue(isOp()); } else { return permission.getDefault().getValue(isOp()); @@ -115,19 +118,27 @@ public class LPPermissible extends PermissibleBase { } @Override - public boolean hasPermission(@NonNull String permission) { - Tristate ts = user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission, CheckOrigin.PLATFORM_PERMISSION_CHECK); + public boolean hasPermission(String permission) { + if (permission == null) { + throw new NullPointerException("permission"); + } + + Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission, CheckOrigin.PLATFORM_PERMISSION_CHECK); return ts != Tristate.UNDEFINED ? ts.asBoolean() : Permission.DEFAULT_PERMISSION.getValue(isOp()); } @Override - public boolean hasPermission(@NonNull Permission permission) { - Tristate ts = user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission.getName(), CheckOrigin.PLATFORM_PERMISSION_CHECK); + public boolean hasPermission(Permission permission) { + if (permission == null) { + throw new NullPointerException("permission"); + } + + Tristate ts = this.user.getCachedData().getPermissionData(calculateContexts()).getPermissionValue(permission.getName(), CheckOrigin.PLATFORM_PERMISSION_CHECK); if (ts != Tristate.UNDEFINED) { return ts.asBoolean(); } - if (!plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) { + if (!this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUKKIT_DEFAULT_PERMISSIONS)) { return Permission.DEFAULT_PERMISSION.getValue(isOp()); } else { return permission.getDefault().getValue(isOp()); @@ -152,21 +163,21 @@ public class LPPermissible extends PermissibleBase { * @return the calculated contexts for the player. */ private Contexts calculateContexts() { - return plugin.getContextManager().getApplicableContexts(player); + return this.plugin.getContextManager().getApplicableContexts(this.player); } @Override public void setOp(boolean value) { - player.setOp(value); + this.player.setOp(value); } @Override public Set getEffectivePermissions() { - Set> permissions = user.getCachedData().getPermissionData(calculateContexts()).getImmutableBacking().entrySet(); + Set> permissions = this.user.getCachedData().getPermissionData(calculateContexts()).getImmutableBacking().entrySet(); Set ret = new HashSet<>(permissions.size()); for (Map.Entry entry : permissions) { - ret.add(new PermissionAttachmentInfo(player, entry.getKey(), null, entry.getValue())); + ret.add(new PermissionAttachmentInfo(this.player, entry.getKey(), null, entry.getValue())); } return ret; @@ -174,20 +185,35 @@ public class LPPermissible extends PermissibleBase { @Override public LPPermissionAttachment addAttachment(Plugin plugin) { + if (plugin == null) { + throw new NullPointerException("plugin"); + } + LPPermissionAttachment ret = new LPPermissionAttachment(this, plugin); ret.hook(); return ret; } @Override - public PermissionAttachment addAttachment(Plugin plugin, @NonNull String name, boolean value) { + public PermissionAttachment addAttachment(Plugin plugin, String permission, boolean value) { + if (plugin == null) { + throw new NullPointerException("plugin"); + } + if (permission == null) { + throw new NullPointerException("permission"); + } + PermissionAttachment ret = addAttachment(plugin); - ret.setPermission(name, value); + ret.setPermission(permission, value); return ret; } @Override - public LPPermissionAttachment addAttachment(@NonNull Plugin plugin, int ticks) { + public LPPermissionAttachment addAttachment(Plugin plugin, int ticks) { + if (plugin == null) { + throw new NullPointerException("plugin"); + } + if (!plugin.isEnabled()) { throw new IllegalArgumentException("Plugin " + plugin.getDescription().getFullName() + " is not enabled"); } @@ -195,20 +221,31 @@ public class LPPermissible extends PermissibleBase { LPPermissionAttachment ret = addAttachment(plugin); if (getPlugin().getServer().getScheduler().scheduleSyncDelayedTask(plugin, ret::remove, ticks) == -1) { ret.remove(); - throw new RuntimeException("Could not add PermissionAttachment to " + player + " for plugin " + plugin.getDescription().getFullName() + ": Scheduler returned -1"); + throw new RuntimeException("Could not add PermissionAttachment to " + this.player + " for plugin " + plugin.getDescription().getFullName() + ": Scheduler returned -1"); } return ret; } @Override - public LPPermissionAttachment addAttachment(Plugin plugin, @NonNull String name, boolean value, int ticks) { + public LPPermissionAttachment addAttachment(Plugin plugin, String permission, boolean value, int ticks) { + if (plugin == null) { + throw new NullPointerException("plugin"); + } + if (permission == null) { + throw new NullPointerException("permission"); + } + LPPermissionAttachment ret = addAttachment(plugin, ticks); - ret.setPermission(name, value); + ret.setPermission(permission, value); return ret; } @Override - public void removeAttachment(@NonNull PermissionAttachment attachment) { + public void removeAttachment(PermissionAttachment attachment) { + if (attachment == null) { + throw new NullPointerException("attachment"); + } + if (!(attachment instanceof LPPermissionAttachment)) { throw new IllegalArgumentException("Given attachment is not a LPPermissionAttachment."); } @@ -228,6 +265,30 @@ public class LPPermissible extends PermissibleBase { @Override public void clearPermissions() { - attachments.forEach(LPPermissionAttachment::remove); + this.attachments.forEach(LPPermissionAttachment::remove); + } + + public User getUser() { + return this.user; + } + + public Player getPlayer() { + return this.player; + } + + public LPBukkitPlugin getPlugin() { + return this.plugin; + } + + public PermissibleBase getOldPermissible() { + return this.oldPermissible; + } + + public AtomicBoolean getActive() { + return this.active; + } + + public void setOldPermissible(PermissibleBase oldPermissible) { + this.oldPermissible = oldPermissible; } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissionAttachment.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissionAttachment.java index 069486770..8540392df 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissionAttachment.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPPermissionAttachment.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.bukkit.model; -import lombok.Getter; -import lombok.Setter; - import com.google.common.base.Preconditions; import me.lucko.luckperms.api.Node; @@ -45,6 +42,7 @@ import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Map; +import java.util.Objects; import java.util.Set; /** @@ -74,7 +72,6 @@ public class LPPermissionAttachment extends PermissionAttachment { /** * The parent LPPermissible */ - @Getter private final LPPermissible permissible; /** @@ -95,8 +92,6 @@ public class LPPermissionAttachment extends PermissionAttachment { /** * Callback to run when the attachment is removed */ - @Getter - @Setter private PermissionRemovedExecutor removalCallback = null; public LPPermissionAttachment(LPPermissible permissible, Plugin owner) { @@ -113,7 +108,7 @@ public class LPPermissionAttachment extends PermissionAttachment { this.owner = null; // copy - perms.putAll(bukkit.getPermissions()); + this.perms.putAll(bukkit.getPermissions()); injectFakeMap(); } @@ -138,13 +133,28 @@ public class LPPermissionAttachment extends PermissionAttachment { } } + @Override + public LPPermissible getPermissible() { + return this.permissible; + } + + @Override + public PermissionRemovedExecutor getRemovalCallback() { + return this.removalCallback; + } + + @Override + public void setRemovalCallback(PermissionRemovedExecutor removalCallback) { + this.removalCallback = removalCallback; + } + /** * Hooks this attachment with the parent {@link User} instance. */ public void hook() { - hooked = true; - permissible.attachments.add(this); - for (Map.Entry entry : perms.entrySet()) { + this.hooked = true; + this.permissible.attachments.add(this); + for (Map.Entry entry : this.perms.entrySet()) { if (entry.getKey() == null || entry.getKey().isEmpty()) { continue; } @@ -153,7 +163,7 @@ public class LPPermissionAttachment extends PermissionAttachment { } private void setPermissionInternal(String name, boolean value) { - if (!permissible.getPlugin().getConfiguration().get(ConfigKeys.APPLY_BUKKIT_ATTACHMENT_PERMISSIONS)) { + if (!this.permissible.getPlugin().getConfiguration().get(ConfigKeys.APPLY_BUKKIT_ATTACHMENT_PERMISSIONS)) { return; } @@ -161,26 +171,26 @@ public class LPPermissionAttachment extends PermissionAttachment { // we use the servers static context to *try* to ensure that the node will apply Node node = NodeFactory.builder(name) .setValue(value) - .withExtraContext(permissible.getPlugin().getContextManager().getStaticContext()) + .withExtraContext(this.permissible.getPlugin().getContextManager().getStaticContext()) .build(); // convert the constructed node to a transient node instance to refer back to this attachment ImmutableTransientNode transientNode = ImmutableTransientNode.of(node, this); // set the transient node - User user = permissible.getUser(); + User user = this.permissible.getUser(); if (user.setTransientPermission(transientNode).asBoolean()) { user.reloadCachedData(); } } private void unsetPermissionInternal(String name) { - if (!permissible.getPlugin().getConfiguration().get(ConfigKeys.APPLY_BUKKIT_ATTACHMENT_PERMISSIONS)) { + if (!this.permissible.getPlugin().getConfiguration().get(ConfigKeys.APPLY_BUKKIT_ATTACHMENT_PERMISSIONS)) { return; } // remove transient permissions from the holder which were added by this attachment & equal the permission - User user = permissible.getUser(); + User user = this.permissible.getUser(); if (user.removeIfTransient(n -> n instanceof ImmutableTransientNode && ((ImmutableTransientNode) n).getOwner() == this && n.getPermission().equals(name))) { user.reloadCachedData(); } @@ -188,7 +198,7 @@ public class LPPermissionAttachment extends PermissionAttachment { private void clearInternal() { // remove all transient permissions added by this attachment - User user = permissible.getUser(); + User user = this.permissible.getUser(); if (user.removeIfTransient(n -> n instanceof ImmutableTransientNode && ((ImmutableTransientNode) n).getOwner() == this)) { user.reloadCachedData(); } @@ -196,7 +206,7 @@ public class LPPermissionAttachment extends PermissionAttachment { @Override public boolean remove() { - if (!hooked) { + if (!this.hooked) { return false; } @@ -204,31 +214,31 @@ public class LPPermissionAttachment extends PermissionAttachment { clearInternal(); // run the callback - if (removalCallback != null) { - removalCallback.attachmentRemoved(this); + if (this.removalCallback != null) { + this.removalCallback.attachmentRemoved(this); } // unhook from the permissible - hooked = false; - permissible.attachments.remove(this); + this.hooked = false; + this.permissible.attachments.remove(this); return true; } @Override public void setPermission(String name, boolean value) { - Preconditions.checkNotNull(name, "name is null"); + Objects.requireNonNull(name, "name is null"); Preconditions.checkArgument(!name.isEmpty(), "name is empty"); String permission = name.toLowerCase(); - Boolean previous = perms.put(permission, value); + Boolean previous = this.perms.put(permission, value); if (previous != null && previous == value) { return; } // if we're not hooked, then don't actually apply the change // it will get applied on hook - if that ever happens - if (!hooked) { + if (!this.hooked) { return; } @@ -241,19 +251,19 @@ public class LPPermissionAttachment extends PermissionAttachment { @Override public void unsetPermission(String name) { - Preconditions.checkNotNull(name, "name is null"); + Objects.requireNonNull(name, "name is null"); Preconditions.checkArgument(!name.isEmpty(), "name is empty"); String permission = name.toLowerCase(); - Boolean previous = perms.remove(permission); + Boolean previous = this.perms.remove(permission); if (previous == null) { return; } // if we're not hooked, then don't actually apply the change // it will get applied on hook - if that ever happens - if (!hooked) { + if (!this.hooked) { return; } @@ -262,12 +272,12 @@ public class LPPermissionAttachment extends PermissionAttachment { @Override public Map getPermissions() { - return perms; + return this.perms; } @Override public Plugin getPlugin() { - return owner != null ? owner : permissible.getPlugin(); + return this.owner != null ? this.owner : this.permissible.getPlugin(); } @Override @@ -295,7 +305,7 @@ public class LPPermissionAttachment extends PermissionAttachment { @Override public Boolean put(String key, Boolean value) { // grab the previous result, so we can still satisfy the method signature of Map - Boolean previous = perms.get(key); + Boolean previous = LPPermissionAttachment.this.perms.get(key); // proxy the call back through the PermissionAttachment instance setPermission(key, value); @@ -314,7 +324,7 @@ public class LPPermissionAttachment extends PermissionAttachment { String permission = ((String) key); // grab the previous result, so we can still satisfy the method signature of Map - Boolean previous = perms.get(permission); + Boolean previous = LPPermissionAttachment.this.perms.get(permission); // proxy the call back through the PermissionAttachment instance unsetPermission(permission); @@ -333,61 +343,61 @@ public class LPPermissionAttachment extends PermissionAttachment { @Override public void clear() { // remove the permissions which have already been applied - if (hooked) { + if (LPPermissionAttachment.this.hooked) { clearInternal(); } // clear the backing map - perms.clear(); + LPPermissionAttachment.this.perms.clear(); } @Override public int size() { // return the size of the permissions map - probably the most accurate value we have - return perms.size(); + return LPPermissionAttachment.this.perms.size(); } @Override public boolean isEmpty() { // return if the permissions map is empty - again probably the most accurate thing // we can return - return perms.isEmpty(); + return LPPermissionAttachment.this.perms.isEmpty(); } @Override public boolean containsKey(Object key) { // just proxy - return perms.containsKey(key); + return LPPermissionAttachment.this.perms.containsKey(key); } @Override public boolean containsValue(Object value) { // just proxy - return perms.containsValue(value); + return LPPermissionAttachment.this.perms.containsValue(value); } @Override public Boolean get(Object key) { // just proxy - return perms.get(key); + return LPPermissionAttachment.this.perms.get(key); } @Override public Set keySet() { // just proxy - return perms.keySet(); + return LPPermissionAttachment.this.perms.keySet(); } @Override public Collection values() { // just proxy - return perms.values(); + return LPPermissionAttachment.this.perms.values(); } @Override public Set> entrySet() { // just proxy - return perms.entrySet(); + return LPPermissionAttachment.this.perms.entrySet(); } } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPSubscriptionMap.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPSubscriptionMap.java index 81049ad89..e88f7dbaa 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPSubscriptionMap.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/LPSubscriptionMap.java @@ -44,6 +44,8 @@ import java.util.Set; import java.util.WeakHashMap; import java.util.stream.Collectors; +import javax.annotation.Nonnull; + /** * A replacement map for the 'permSubs' instance in Bukkit's SimplePluginManager. * @@ -171,13 +173,13 @@ public class LPSubscriptionMap extends HashMap // if the key is a player, check their LPPermissible first if (isPlayer) { Permissible p = (Permissible) key; - if (p.isPermissionSet(permission)) { - return p.hasPermission(permission); + if (p.isPermissionSet(this.permission)) { + return p.hasPermission(this.permission); } } // then try the map - Boolean result = backing.get(key); + Boolean result = this.backing.get(key); if (result != null) { return result; } @@ -185,8 +187,8 @@ public class LPSubscriptionMap extends HashMap // then try the permissible, if we haven't already if (!isPlayer && key instanceof Permissible) { Permissible p = (Permissible) key; - if (p.isPermissionSet(permission)) { - return p.hasPermission(permission); + if (p.isPermissionSet(this.permission)) { + return p.hasPermission(this.permission); } } @@ -200,17 +202,19 @@ public class LPSubscriptionMap extends HashMap return get(key) != null; } + @Nonnull @Override public Set keySet() { // gather players (LPPermissibles) - Set players = plugin.getServer().getOnlinePlayers().stream() - .filter(player -> player.isPermissionSet(permission)) + Set players = LPSubscriptionMap.this.plugin.getServer().getOnlinePlayers().stream() + .filter(player -> player.isPermissionSet(this.permission)) .collect(Collectors.toSet()); // then combine the players with the backing map - return Sets.union(players, backing.keySet()); + return Sets.union(players, this.backing.keySet()); } + @Nonnull @Override public Set> entrySet() { return keySet().stream() @@ -233,39 +237,40 @@ public class LPSubscriptionMap extends HashMap @Override public Boolean put(Permissible key, Boolean value) { - return backing.put(key, value); + return this.backing.put(key, value); } @Override public Boolean remove(Object key) { - return backing.remove(key); + return this.backing.remove(key); } // the following methods are not used in the current impls of PluginManager, but just delegate them for now @Override public int size() { - return backing.size(); + return this.backing.size(); } @Override public boolean containsValue(Object value) { - return backing.containsValue(value); + return this.backing.containsValue(value); } @Override - public void putAll(Map m) { - backing.putAll(m); + public void putAll(@Nonnull Map m) { + this.backing.putAll(m); } @Override public void clear() { - backing.clear(); + this.backing.clear(); } + @Nonnull @Override public Collection values() { - return backing.values(); + return this.backing.values(); } } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/PermissibleInjector.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/PermissibleInjector.java index 6c634e9c1..aba91b4c0 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/PermissibleInjector.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/PermissibleInjector.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.model; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.bukkit.compat.ReflectionUtil; import org.bukkit.entity.Player; @@ -42,8 +40,7 @@ import java.util.List; * This allows LuckPerms to directly intercept permission checks and take over all handling of * checks made by plugins. */ -@UtilityClass -public class PermissibleInjector { +public final class PermissibleInjector { /** * All permission checks made on standard Bukkit objects are effectively proxied to a @@ -162,4 +159,6 @@ public class PermissibleInjector { } } + private PermissibleInjector() {} + } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/SubscriptionMapInjector.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/SubscriptionMapInjector.java index 4c7f4e5e4..ea4e8348d 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/SubscriptionMapInjector.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/model/SubscriptionMapInjector.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.model; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.bukkit.LPBukkitPlugin; import org.bukkit.Bukkit; @@ -37,7 +35,6 @@ import org.bukkit.plugin.SimplePluginManager; import java.lang.reflect.Field; import java.util.Map; -@RequiredArgsConstructor public class SubscriptionMapInjector implements Runnable { private static final Field PERM_SUBS_FIELD; @@ -54,22 +51,26 @@ public class SubscriptionMapInjector implements Runnable { private final LPBukkitPlugin plugin; + public SubscriptionMapInjector(LPBukkitPlugin plugin) { + this.plugin = plugin; + } + @Override public void run() { try { inject(); } catch (Exception e) { - plugin.getLog().severe("Exception occurred whilst injecting LuckPerms Permission Subscription map."); + this.plugin.getLog().severe("Exception occurred whilst injecting LuckPerms Permission Subscription map."); e.printStackTrace(); } } private void inject() throws Exception { - PluginManager pluginManager = plugin.getServer().getPluginManager(); + PluginManager pluginManager = this.plugin.getServer().getPluginManager(); if (!(pluginManager instanceof SimplePluginManager)) { - plugin.getLog().severe("PluginManager instance is not a 'SimplePluginManager', instead: " + pluginManager.getClass()); - plugin.getLog().severe("Unable to inject LuckPerms Permission Subscription map."); + this.plugin.getLog().severe("PluginManager instance is not a 'SimplePluginManager', instead: " + pluginManager.getClass()); + this.plugin.getLog().severe("Unable to inject LuckPerms Permission Subscription map."); return; } @@ -82,7 +83,7 @@ public class SubscriptionMapInjector implements Runnable { Map> castedMap = (Map>) map; // make a new subscription map - LPSubscriptionMap newMap = new LPSubscriptionMap(plugin, castedMap); + LPSubscriptionMap newMap = new LPSubscriptionMap(this.plugin, castedMap); // inject it PERM_SUBS_FIELD.set(pluginManager, newMap); diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/BukkitProcessorsSetupTask.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/BukkitProcessorsSetupTask.java index 5d00fc37b..cd5eec915 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/BukkitProcessorsSetupTask.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/BukkitProcessorsSetupTask.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.processors; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.bukkit.LPBukkitPlugin; import java.util.HashSet; @@ -35,21 +33,24 @@ import java.util.Set; /** * Performs the initial setup for Bukkit permission processors */ -@RequiredArgsConstructor public class BukkitProcessorsSetupTask implements Runnable { private final LPBukkitPlugin plugin; + public BukkitProcessorsSetupTask(LPBukkitPlugin plugin) { + this.plugin = plugin; + } + @Override public void run() { - plugin.getDefaultsProvider().refresh(); - plugin.getChildPermissionProvider().setup(); + this.plugin.getDefaultsProvider().refresh(); + this.plugin.getChildPermissionProvider().setup(); Set perms = new HashSet<>(); - plugin.getServer().getPluginManager().getPermissions().forEach(p -> { + this.plugin.getServer().getPluginManager().getPermissions().forEach(p -> { perms.add(p.getName()); perms.addAll(p.getChildren().keySet()); }); - perms.forEach(p -> plugin.getPermissionVault().offer(p)); + perms.forEach(p -> this.plugin.getPermissionVault().offer(p)); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildPermissionProvider.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildPermissionProvider.java index 1b38b927b..539161540 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildPermissionProvider.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildPermissionProvider.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.processors; -import lombok.Getter; - import com.google.common.collect.ImmutableMap; import com.google.common.collect.Maps; @@ -51,7 +49,6 @@ import java.util.Map; public class ChildPermissionProvider { // in the format: permission+value ===> children (a map of child permissions) - @Getter private ImmutableMap, ImmutableMap> permissions = ImmutableMap.of(); public void setup() { @@ -102,4 +99,9 @@ public class ChildPermissionProvider { } } } + + public ImmutableMap, ImmutableMap> getPermissions() { + return this.permissions; + } + } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java index 42cb10f19..29f28a776 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/ChildProcessor.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.processors; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.Maps; import me.lucko.luckperms.api.Tristate; @@ -38,23 +36,26 @@ import java.util.concurrent.ConcurrentHashMap; /** * Permission Processor for Bukkits "child" permission system. */ -@RequiredArgsConstructor public class ChildProcessor implements PermissionProcessor { private final ChildPermissionProvider provider; private final Map childPermissions = new ConcurrentHashMap<>(); + public ChildProcessor(ChildPermissionProvider provider) { + this.provider = provider; + } + @Override public Tristate hasPermission(String permission) { - return Tristate.fromNullableBoolean(childPermissions.get(permission)); + return Tristate.fromNullableBoolean(this.childPermissions.get(permission)); } @Override public void updateBacking(Map map) { - childPermissions.clear(); + this.childPermissions.clear(); for (Map.Entry e : map.entrySet()) { - Map children = provider.getPermissions().get(Maps.immutableEntry(e.getKey(), e.getValue())); + Map children = this.provider.getPermissions().get(Maps.immutableEntry(e.getKey(), e.getValue())); if (children != null) { - childPermissions.putAll(children); + this.childPermissions.putAll(children); } } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java index dd277054d..164adbb30 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProcessor.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.processors; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.processors.PermissionProcessor; @@ -38,20 +36,24 @@ import java.util.Map; /** * Permission Processor for Bukkits "default" permission system. */ -@AllArgsConstructor public class DefaultsProcessor implements PermissionProcessor { private final boolean isOp; private final DefaultsProvider defaultsProvider; + public DefaultsProcessor(boolean isOp, DefaultsProvider defaultsProvider) { + this.isOp = isOp; + this.defaultsProvider = defaultsProvider; + } + @Override public Tristate hasPermission(String permission) { - Tristate t = defaultsProvider.lookup(permission, isOp); + Tristate t = this.defaultsProvider.lookup(permission, this.isOp); if (t != Tristate.UNDEFINED) { return t; } Permission defPerm = Bukkit.getServer().getPluginManager().getPermission(permission); - return defPerm == null ? Tristate.UNDEFINED : Tristate.fromBoolean(defPerm.getDefault().getValue(isOp)); + return defPerm == null ? Tristate.UNDEFINED : Tristate.fromBoolean(defPerm.getDefault().getValue(this.isOp)); } @Override diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProvider.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProvider.java index 10bf536c8..1b9656978 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProvider.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/processors/DefaultsProvider.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.processors; -import lombok.Getter; - import com.google.common.collect.ImmutableMap; import me.lucko.luckperms.api.Tristate; @@ -54,12 +52,10 @@ import java.util.Set; public class DefaultsProvider { // defaults for opped players - @Getter private Map opDefaults = ImmutableMap.of(); private final DummyPermissible opDummy = new DummyPermissible(this::refreshOp); // defaults for non-opped players - @Getter private Map nonOpDefaults = ImmutableMap.of(); private final DummyPermissible nonOpDummy = new DummyPermissible(this::refreshNonOp); @@ -79,7 +75,7 @@ public class DefaultsProvider { * @return a tristate result */ public Tristate lookup(String permission, boolean isOp) { - Map map = isOp ? opDefaults : nonOpDefaults; + Map map = isOp ? this.opDefaults : this.nonOpDefaults; return Tristate.fromNullableBoolean(map.get(permission)); } @@ -89,39 +85,39 @@ public class DefaultsProvider { * @return the number of permissions held */ public int size() { - return opDefaults.size() + nonOpDefaults.size(); + return this.opDefaults.size() + this.nonOpDefaults.size(); } /** * Refreshes the op data in this provider. */ private void refreshOp() { - unregisterDefaults(opDefaults, opDummy, true); + unregisterDefaults(this.opDefaults, this.opDummy, true); Map builder = new HashMap<>(); - calculateDefaults(builder, opDummy, true); + calculateDefaults(builder, this.opDummy, true); - opDefaults = ImmutableMap.copyOf(builder); + this.opDefaults = ImmutableMap.copyOf(builder); } /** * Refreshes the non op data in this provider. */ private void refreshNonOp() { - unregisterDefaults(nonOpDefaults, nonOpDummy, false); + unregisterDefaults(this.nonOpDefaults, this.nonOpDummy, false); Map builder = new HashMap<>(); - calculateDefaults(builder, nonOpDummy, false); + calculateDefaults(builder, this.nonOpDummy, false); - nonOpDefaults = ImmutableMap.copyOf(builder); + this.nonOpDefaults = ImmutableMap.copyOf(builder); } /** * Unregisters the dummy permissibles with Bukkit. */ public void close() { - unregisterDefaults(opDefaults, opDummy, true); - unregisterDefaults(nonOpDefaults, nonOpDummy, false); + unregisterDefaults(this.opDefaults, this.opDummy, true); + unregisterDefaults(this.nonOpDefaults, this.nonOpDummy, false); } private static PluginManager pm() { diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultChat.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultChat.java index 7ebd3da6a..6c51db725 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultChat.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultChat.java @@ -146,7 +146,7 @@ public abstract class AbstractVaultChat extends Chat { } private String world(String world) { - return worldMappingFunction.apply(world); + return this.worldMappingFunction.apply(world); } private String world(Player player) { @@ -525,67 +525,67 @@ public abstract class AbstractVaultChat extends Chat { @Override public boolean playerInGroup(String world, OfflinePlayer player, String group) { - return permissionApi.playerInGroup(world, player, group); + return this.permissionApi.playerInGroup(world, player, group); } @Override public boolean playerInGroup(String world, String player, String group) { - return permissionApi.playerInGroup(world, player, group); + return this.permissionApi.playerInGroup(world, player, group); } @Override public boolean playerInGroup(World world, String player, String group) { - return permissionApi.playerInGroup(world, player, group); + return this.permissionApi.playerInGroup(world, player, group); } @Override public boolean playerInGroup(Player player, String group) { - return permissionApi.playerInGroup(player, group); + return this.permissionApi.playerInGroup(player, group); } @Override public String[] getPlayerGroups(String world, OfflinePlayer player) { - return permissionApi.getPlayerGroups(world, player); + return this.permissionApi.getPlayerGroups(world, player); } @Override public String[] getPlayerGroups(String world, String player) { - return permissionApi.getPlayerGroups(world, player); + return this.permissionApi.getPlayerGroups(world, player); } @Override public String[] getPlayerGroups(World world, String player) { - return permissionApi.getPlayerGroups(world, player); + return this.permissionApi.getPlayerGroups(world, player); } @Override public String[] getPlayerGroups(Player player) { - return permissionApi.getPlayerGroups(player); + return this.permissionApi.getPlayerGroups(player); } @Override public String getPrimaryGroup(String world, OfflinePlayer player) { - return permissionApi.getPrimaryGroup(world, player); + return this.permissionApi.getPrimaryGroup(world, player); } @Override public String getPrimaryGroup(String world, String player) { - return permissionApi.getPrimaryGroup(world, player); + return this.permissionApi.getPrimaryGroup(world, player); } @Override public String getPrimaryGroup(World world, String player) { - return permissionApi.getPrimaryGroup(world, player); + return this.permissionApi.getPrimaryGroup(world, player); } @Override public String getPrimaryGroup(Player player) { - return permissionApi.getPrimaryGroup(player); + return this.permissionApi.getPrimaryGroup(player); } @Override public String[] getGroups() { - return permissionApi.getGroups(); + return this.permissionApi.getGroups(); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultPermission.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultPermission.java index 13cbd03b6..46048afd0 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultPermission.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/AbstractVaultPermission.java @@ -110,7 +110,7 @@ public abstract class AbstractVaultPermission extends Permission { } private String world(String world) { - return worldMappingFunction.apply(world); + return this.worldMappingFunction.apply(world); } private String world(Player player) { diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultChatHook.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultChatHook.java index b606672d4..12e2b437c 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultChatHook.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultChatHook.java @@ -25,7 +25,6 @@ package me.lucko.luckperms.bukkit.vault; -import com.google.common.base.Preconditions; import com.google.common.base.Strings; import me.lucko.luckperms.api.ChatMetaType; @@ -44,6 +43,7 @@ import me.lucko.luckperms.common.node.NodeFactory; import net.milkbowl.vault.chat.Chat; +import java.util.Objects; import java.util.UUID; /** @@ -78,18 +78,19 @@ public class VaultChatHook extends AbstractVaultChat { this.worldMappingFunction = world -> permissionHook.isIgnoreWorld() ? null : world; } + @Override public String getName() { return "LuckPerms"; } @Override public String getPlayerPrefix(String world, UUID uuid) { - Preconditions.checkNotNull(uuid, "uuid"); + Objects.requireNonNull(uuid, "uuid"); User user = getUser(uuid); if (user == null) { return null; } - Contexts contexts = permissionHook.contextForLookup(user, world); + Contexts contexts = this.permissionHook.contextForLookup(user, world); MetaCache metaData = user.getCachedData().getMetaData(contexts); String ret = metaData.getPrefix(); if (log()) { @@ -100,12 +101,12 @@ public class VaultChatHook extends AbstractVaultChat { @Override public String getPlayerSuffix(String world, UUID uuid) { - Preconditions.checkNotNull(uuid, "uuid"); + Objects.requireNonNull(uuid, "uuid"); User user = getUser(uuid); if (user == null) { return null; } - Contexts contexts = permissionHook.contextForLookup(user, world); + Contexts contexts = this.permissionHook.contextForLookup(user, world); MetaCache metaData = user.getCachedData().getMetaData(contexts); String ret = metaData.getSuffix(); if (log()) { @@ -116,7 +117,7 @@ public class VaultChatHook extends AbstractVaultChat { @Override public void setPlayerPrefix(String world, UUID uuid, String prefix) { - Preconditions.checkNotNull(uuid, "uuid"); + Objects.requireNonNull(uuid, "uuid"); User user = getUser(uuid); if (user == null) { return; @@ -126,7 +127,7 @@ public class VaultChatHook extends AbstractVaultChat { @Override public void setPlayerSuffix(String world, UUID uuid, String suffix) { - Preconditions.checkNotNull(uuid, "uuid"); + Objects.requireNonNull(uuid, "uuid"); User user = getUser(uuid); if (user == null) { return; @@ -136,13 +137,13 @@ public class VaultChatHook extends AbstractVaultChat { @Override public String getPlayerInfo(String world, UUID uuid, String key) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(key, "key"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(key, "key"); User user = getUser(uuid); if (user == null) { return null; } - Contexts contexts = permissionHook.contextForLookup(user, world); + Contexts contexts = this.permissionHook.contextForLookup(user, world); MetaCache metaData = user.getCachedData().getMetaData(contexts); String ret = metaData.getMeta().get(key); if (log()) { @@ -153,8 +154,8 @@ public class VaultChatHook extends AbstractVaultChat { @Override public void setPlayerInfo(String world, UUID uuid, String key, Object value) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(key, "key"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(key, "key"); User user = getUser(uuid); if (user == null) { return; @@ -164,12 +165,12 @@ public class VaultChatHook extends AbstractVaultChat { @Override public String getGroupsPrefix(String world, String name) { - Preconditions.checkNotNull(name, "name"); + Objects.requireNonNull(name, "name"); Group group = getGroup(name); if (group == null) { return null; } - Contexts contexts = permissionHook.contextForLookup(null, world); + Contexts contexts = this.permissionHook.contextForLookup(null, world); MetaCache metaData = group.getCachedData().getMetaData(contexts); String ret = metaData.getPrefix(); if (log()) { @@ -180,12 +181,12 @@ public class VaultChatHook extends AbstractVaultChat { @Override public String getGroupsSuffix(String world, String name) { - Preconditions.checkNotNull(name, "name"); + Objects.requireNonNull(name, "name"); Group group = getGroup(name); if (group == null) { return null; } - Contexts contexts = permissionHook.contextForLookup(null, world); + Contexts contexts = this.permissionHook.contextForLookup(null, world); MetaCache metaData = group.getCachedData().getMetaData(contexts); String ret = metaData.getSuffix(); if (log()) { @@ -196,7 +197,7 @@ public class VaultChatHook extends AbstractVaultChat { @Override public void setGroupsPrefix(String world, String name, String prefix) { - Preconditions.checkNotNull(name, "name"); + Objects.requireNonNull(name, "name"); Group group = getGroup(name); if (group == null) { return; @@ -206,7 +207,7 @@ public class VaultChatHook extends AbstractVaultChat { @Override public void setGroupsSuffix(String world, String name, String suffix) { - Preconditions.checkNotNull(name, "name"); + Objects.requireNonNull(name, "name"); Group group = getGroup(name); if (group == null) { return; @@ -216,13 +217,13 @@ public class VaultChatHook extends AbstractVaultChat { @Override public String getGroupInfo(String world, String name, String key) { - Preconditions.checkNotNull(name, "name"); - Preconditions.checkNotNull(key, "key"); + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(key, "key"); Group group = getGroup(name); if (group == null) { return null; } - Contexts contexts = permissionHook.contextForLookup(null, world); + Contexts contexts = this.permissionHook.contextForLookup(null, world); MetaCache metaData = group.getCachedData().getMetaData(contexts); String ret = metaData.getMeta().get(key); if (log()) { @@ -233,8 +234,8 @@ public class VaultChatHook extends AbstractVaultChat { @Override public void setGroupInfo(String world, String name, String key, Object value) { - Preconditions.checkNotNull(name, "name"); - Preconditions.checkNotNull(key, "key"); + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(key, "key"); Group group = getGroup(name); if (group == null) { return; @@ -245,19 +246,19 @@ public class VaultChatHook extends AbstractVaultChat { // utility methods for getting user and group instances private User getUser(UUID uuid) { - return plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(uuid)); + return this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(uuid)); } private Group getGroup(String name) { - return plugin.getGroupManager().getByDisplayName(name); + return this.plugin.getGroupManager().getByDisplayName(name); } // logging private boolean log() { - return plugin.getConfiguration().get(ConfigKeys.VAULT_DEBUG); + return this.plugin.getConfiguration().get(ConfigKeys.VAULT_DEBUG); } private void logMsg(String format, Object... args) { - plugin.getLog().info("[VAULT-CHAT] " + String.format(format, args) + this.plugin.getLog().info("[VAULT-CHAT] " + String.format(format, args) .replace(CommandManager.SECTION_CHAR, '$') .replace(CommandManager.AMPERSAND_CHAR, '$') ); @@ -268,12 +269,12 @@ public class VaultChatHook extends AbstractVaultChat { logMsg("#setChatMeta: %s - %s - %s - %s", holder.getFriendlyName(), type, value, world); } - permissionHook.getExecutor().execute(() -> { + this.permissionHook.getExecutor().execute(() -> { // remove all prefixes/suffixes directly set on the user/group holder.removeIf(type::matches); if (value == null) { - permissionHook.holderSave(holder); + this.permissionHook.holderSave(holder); return; } @@ -283,11 +284,11 @@ public class VaultChatHook extends AbstractVaultChat { .mapToInt(e -> e).max().orElse(0) + 10; Node.Builder chatMetaNode = NodeFactory.buildChatMetaNode(type, priority, value); - chatMetaNode.setServer(permissionHook.getVaultServer()); + chatMetaNode.setServer(this.permissionHook.getVaultServer()); chatMetaNode.setWorld(world); holder.setPermission(chatMetaNode.build()); - permissionHook.holderSave(holder); + this.permissionHook.holderSave(holder); }); } @@ -296,11 +297,11 @@ public class VaultChatHook extends AbstractVaultChat { logMsg("#setMeta: %s - %s - %s - %s", holder.getFriendlyName(), key, value, world); } - permissionHook.getExecutor().execute(() -> { + this.permissionHook.getExecutor().execute(() -> { holder.removeIf(n -> n.isMeta() && n.getMeta().getKey().equals(key)); if (value == null) { - permissionHook.holderSave(holder); + this.permissionHook.holderSave(holder); return; } @@ -311,11 +312,11 @@ public class VaultChatHook extends AbstractVaultChat { metaNode = NodeFactory.buildMetaNode(key, value.toString()); } - metaNode.setServer(permissionHook.getVaultServer()); + metaNode.setServer(this.permissionHook.getVaultServer()); metaNode.setWorld(world); holder.setPermission(metaNode.build()); - permissionHook.holderSave(holder); + this.permissionHook.holderSave(holder); }); } @@ -324,7 +325,7 @@ public class VaultChatHook extends AbstractVaultChat { if (world != null && !world.equals("") && !world.equalsIgnoreCase("global")) { context.add(Contexts.WORLD_KEY, world.toLowerCase()); } - context.add(Contexts.SERVER_KEY, permissionHook.getVaultServer()); - return new Contexts(context.build(), permissionHook.isIncludeGlobal(), true, true, true, true, false); + context.add(Contexts.SERVER_KEY, this.permissionHook.getVaultServer()); + return new Contexts(context.build(), this.permissionHook.isIncludeGlobal(), true, true, true, true, false); } } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultHookManager.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultHookManager.java index 53bf49327..eea2f4a78 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultHookManager.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultHookManager.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.vault; -import lombok.Getter; - import me.lucko.luckperms.bukkit.LPBukkitPlugin; import net.milkbowl.vault.chat.Chat; @@ -38,7 +36,6 @@ import org.bukkit.plugin.ServicesManager; /** * Handles hooking with the Vault API */ -@Getter public class VaultHookManager { private VaultChatHook chatHook = null; private VaultPermissionHook permissionHook = null; @@ -51,17 +48,17 @@ public class VaultHookManager { */ public void hook(LPBukkitPlugin plugin) { try { - if (permissionHook == null) { - permissionHook = new VaultPermissionHook(plugin); + if (this.permissionHook == null) { + this.permissionHook = new VaultPermissionHook(plugin); } - if (chatHook == null) { - chatHook = new VaultChatHook(plugin, permissionHook); + if (this.chatHook == null) { + this.chatHook = new VaultChatHook(plugin, this.permissionHook); } final ServicesManager sm = plugin.getServer().getServicesManager(); - sm.register(Permission.class, permissionHook, plugin, ServicePriority.High); - sm.register(Chat.class, chatHook, plugin, ServicePriority.High); + sm.register(Permission.class, this.permissionHook, plugin, ServicePriority.High); + sm.register(Chat.class, this.chatHook, plugin, ServicePriority.High); } catch (Exception e) { e.printStackTrace(); @@ -76,25 +73,16 @@ public class VaultHookManager { public void unhook(LPBukkitPlugin plugin) { final ServicesManager sm = plugin.getServer().getServicesManager(); - if (permissionHook != null) { - sm.unregister(Permission.class, permissionHook); - permissionHook.getExecutor().shutdown(); - permissionHook = null; + if (this.permissionHook != null) { + sm.unregister(Permission.class, this.permissionHook); + this.permissionHook.getExecutor().shutdown(); + this.permissionHook = null; } - if (chatHook != null) { - sm.unregister(Chat.class, chatHook); - chatHook = null; + if (this.chatHook != null) { + sm.unregister(Chat.class, this.chatHook); + this.chatHook = null; } } - /** - * Gets if the Vault classes are registered. - * - * @return true if hooked - */ - public boolean isHooked() { - return permissionHook != null && chatHook != null; - } - } diff --git a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultPermissionHook.java b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultPermissionHook.java index 186eff99f..b4f3a97a6 100644 --- a/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultPermissionHook.java +++ b/bukkit/src/main/java/me/lucko/luckperms/bukkit/vault/VaultPermissionHook.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bukkit.vault; -import lombok.Getter; - import com.google.common.base.Preconditions; import me.lucko.luckperms.api.Contexts; @@ -49,6 +47,7 @@ import net.milkbowl.vault.permission.Permission; import org.bukkit.entity.Player; import java.util.Arrays; +import java.util.Objects; import java.util.UUID; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @@ -70,7 +69,6 @@ import java.util.concurrent.Executors; * We cannot risk blocking the main thread to load in their data. Again, this is due to crap Vault * design. There is nothing I can do about it. */ -@Getter public class VaultPermissionHook extends AbstractVaultPermission { // the plugin instance @@ -85,6 +83,14 @@ public class VaultPermissionHook extends AbstractVaultPermission { this.worldMappingFunction = world -> isIgnoreWorld() ? null : world; } + public LPBukkitPlugin getPlugin() { + return this.plugin; + } + + public ExecutorService getExecutor() { + return this.executor; + } + @Override public String getName() { return "LuckPerms"; @@ -104,15 +110,15 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public String[] getGroups() { - return plugin.getGroupManager().getAll().values().stream() + return this.plugin.getGroupManager().getAll().values().stream() .map(g -> g.getDisplayName().orElse(g.getName())) .toArray(String[]::new); } @Override public boolean hasPermission(String world, UUID uuid, String permission) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(permission, "permission"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(permission, "permission"); User user = getUser(uuid); if (user == null) { @@ -131,8 +137,8 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public boolean playerAddPermission(String world, UUID uuid, String permission) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(permission, "permission"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(permission, "permission"); User user = getUser(uuid); if (user == null) { @@ -145,8 +151,8 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public boolean playerRemovePermission(String world, UUID uuid, String permission) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(permission, "permission"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(permission, "permission"); User user = getUser(uuid); if (user == null) { @@ -159,28 +165,28 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public boolean playerInGroup(String world, UUID uuid, String group) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(group, "group"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(group, "group"); return hasPermission(world, uuid, NodeFactory.groupNode(rewriteGroupName(group))); } @Override public boolean playerAddGroup(String world, UUID uuid, String group) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(group, "group"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(group, "group"); return checkGroupExists(group) && playerAddPermission(world, uuid, NodeFactory.groupNode(rewriteGroupName(group))); } @Override public boolean playerRemoveGroup(String world, UUID uuid, String group) { - Preconditions.checkNotNull(uuid, "uuid"); - Preconditions.checkNotNull(group, "group"); + Objects.requireNonNull(uuid, "uuid"); + Objects.requireNonNull(group, "group"); return checkGroupExists(group) && playerRemovePermission(world, uuid, NodeFactory.groupNode(rewriteGroupName(group))); } @Override public String[] playerGetGroups(String world, UUID uuid) { - Preconditions.checkNotNull(uuid, "uuid"); + Objects.requireNonNull(uuid, "uuid"); User user = getUser(uuid); if (user == null) { @@ -193,7 +199,7 @@ public class VaultPermissionHook extends AbstractVaultPermission { .filter(Node::isGroupNode) .filter(n -> n.shouldApplyWithContext(contexts)) .map(n -> { - Group group = plugin.getGroupManager().getIfLoaded(n.getGroupName()); + Group group = this.plugin.getGroupManager().getIfLoaded(n.getGroupName()); if (group != null) { return group.getDisplayName().orElse(group.getName()); } @@ -210,7 +216,7 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public String playerPrimaryGroup(String world, UUID uuid) { - Preconditions.checkNotNull(uuid, "uuid"); + Objects.requireNonNull(uuid, "uuid"); User user = getUser(uuid); if (user == null) { @@ -232,8 +238,8 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public boolean groupHasPermission(String world, String name, String permission) { - Preconditions.checkNotNull(name, "name"); - Preconditions.checkNotNull(permission, "permission"); + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(permission, "permission"); Group group = getGroup(name); if (group == null) { @@ -252,8 +258,8 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public boolean groupAddPermission(String world, String name, String permission) { - Preconditions.checkNotNull(name, "name"); - Preconditions.checkNotNull(permission, "permission"); + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(permission, "permission"); Group group = getGroup(name); if (group == null) { @@ -266,8 +272,8 @@ public class VaultPermissionHook extends AbstractVaultPermission { @Override public boolean groupRemovePermission(String world, String name, String permission) { - Preconditions.checkNotNull(name, "name"); - Preconditions.checkNotNull(permission, "permission"); + Objects.requireNonNull(name, "name"); + Objects.requireNonNull(permission, "permission"); Group group = getGroup(name); if (group == null) { @@ -281,19 +287,19 @@ public class VaultPermissionHook extends AbstractVaultPermission { // utility methods for getting user and group instances private User getUser(UUID uuid) { - return plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(uuid)); + return this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(uuid)); } private Group getGroup(String name) { - return plugin.getGroupManager().getByDisplayName(name); + return this.plugin.getGroupManager().getByDisplayName(name); } private boolean checkGroupExists(String group) { - return plugin.getGroupManager().getByDisplayName(group) != null; + return this.plugin.getGroupManager().getByDisplayName(group) != null; } private String rewriteGroupName(String name) { - Group group = plugin.getGroupManager().getByDisplayName(name); + Group group = this.plugin.getGroupManager().getByDisplayName(name); if (group != null) { return group.getName(); } @@ -302,10 +308,10 @@ public class VaultPermissionHook extends AbstractVaultPermission { // logging private boolean log() { - return plugin.getConfiguration().get(ConfigKeys.VAULT_DEBUG); + return this.plugin.getConfiguration().get(ConfigKeys.VAULT_DEBUG); } private void logMsg(String format, Object... args) { - plugin.getLog().info("[VAULT-PERMS] " + String.format(format, args) + this.plugin.getLog().info("[VAULT-PERMS] " + String.format(format, args) .replace(CommandManager.SECTION_CHAR, '$') .replace(CommandManager.AMPERSAND_CHAR, '$') ); @@ -315,11 +321,11 @@ public class VaultPermissionHook extends AbstractVaultPermission { Contexts contextForLookup(User user, String world) { MutableContextSet context; - Player player = user == null ? null : plugin.getPlayer(user); + Player player = user == null ? null : this.plugin.getPlayer(user); if (player != null) { - context = plugin.getContextManager().getApplicableContext(player).mutableCopy(); + context = this.plugin.getContextManager().getApplicableContext(player).mutableCopy(); } else { - context = plugin.getContextManager().getStaticContext().mutableCopy(); + context = this.plugin.getContextManager().getStaticContext().mutableCopy(); } // if world is null, we want to do a lookup in the players current context @@ -348,14 +354,14 @@ public class VaultPermissionHook extends AbstractVaultPermission { // utility methods for modifying the state of PermissionHolders private void holderAddPermission(PermissionHolder holder, String permission, String world) { - Preconditions.checkNotNull(permission, "permission is null"); + Objects.requireNonNull(permission, "permission is null"); Preconditions.checkArgument(!permission.isEmpty(), "permission is an empty string"); if (log()) { logMsg("#holderAddPermission: %s - %s - %s", holder.getFriendlyName(), permission, world); } - executor.execute(() -> { + this.executor.execute(() -> { if (holder.setPermission(NodeFactory.make(permission, true, getVaultServer(), world)).asBoolean()) { holderSave(holder); } @@ -363,14 +369,14 @@ public class VaultPermissionHook extends AbstractVaultPermission { } private void holderRemovePermission(PermissionHolder holder, String permission, String world) { - Preconditions.checkNotNull(permission, "permission is null"); + Objects.requireNonNull(permission, "permission is null"); Preconditions.checkArgument(!permission.isEmpty(), "permission is an empty string"); if (log()) { logMsg("#holderRemovePermission: %s - %s - %s", holder.getFriendlyName(), permission, world); } - executor.execute(() -> { + this.executor.execute(() -> { if (holder.unsetPermission(NodeFactory.make(permission, getVaultServer(), world)).asBoolean()) { holderSave(holder); } @@ -380,33 +386,33 @@ public class VaultPermissionHook extends AbstractVaultPermission { void holderSave(PermissionHolder holder) { if (holder.getType().isUser()) { User u = (User) holder; - plugin.getStorage().saveUser(u).thenRunAsync(() -> u.getRefreshBuffer().request(), plugin.getScheduler().async()); + this.plugin.getStorage().saveUser(u).thenRunAsync(() -> u.getRefreshBuffer().request(), this.plugin.getScheduler().async()); } if (holder.getType().isGroup()) { Group g = (Group) holder; - plugin.getStorage().saveGroup(g).thenRunAsync(() -> plugin.getUpdateTaskBuffer().request(), plugin.getScheduler().async()); + this.plugin.getStorage().saveGroup(g).thenRunAsync(() -> this.plugin.getUpdateTaskBuffer().request(), this.plugin.getScheduler().async()); } } // helper methods to just pull values from the config. String getServer() { - return plugin.getConfiguration().get(ConfigKeys.SERVER); + return this.plugin.getConfiguration().get(ConfigKeys.SERVER); } String getVaultServer() { - return plugin.getConfiguration().get(ConfigKeys.VAULT_SERVER); + return this.plugin.getConfiguration().get(ConfigKeys.VAULT_SERVER); } boolean isIncludeGlobal() { - return plugin.getConfiguration().get(ConfigKeys.VAULT_INCLUDING_GLOBAL); + return this.plugin.getConfiguration().get(ConfigKeys.VAULT_INCLUDING_GLOBAL); } boolean isIgnoreWorld() { - return plugin.getConfiguration().get(ConfigKeys.VAULT_IGNORE_WORLD); + return this.plugin.getConfiguration().get(ConfigKeys.VAULT_IGNORE_WORLD); } private boolean useVaultServer() { - return plugin.getConfiguration().get(ConfigKeys.USE_VAULT_SERVER); + return this.plugin.getConfiguration().get(ConfigKeys.USE_VAULT_SERVER); } } diff --git a/bungee/pom.xml b/bungee/pom.xml index d87b36a6a..4b7328ba5 100644 --- a/bungee/pom.xml +++ b/bungee/pom.xml @@ -79,11 +79,10 @@ ${project.version} compile - - org.projectlombok - lombok - ${lombok.version} + com.google.code.findbugs + jsr305 + 3.0.2 provided diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCommandExecutor.java b/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCommandExecutor.java index 95bf6f5c6..2fa3a9ea2 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCommandExecutor.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeCommandExecutor.java @@ -53,17 +53,17 @@ public class BungeeCommandExecutor extends Command implements TabExecutor { @Override public void execute(CommandSender sender, String[] args) { - Sender lpSender = plugin.getSenderFactory().wrap(sender); + Sender lpSender = this.plugin.getSenderFactory().wrap(sender); List arguments = CommandManager.stripQuotes(ARGUMENT_SPLITTER.splitToList(ARGUMENT_JOINER.join(args))); - manager.onCommand(lpSender, "lpb", arguments); + this.manager.onCommand(lpSender, "lpb", arguments); } @Override public Iterable onTabComplete(CommandSender sender, String[] args) { - Sender lpSender = plugin.getSenderFactory().wrap(sender); + Sender lpSender = this.plugin.getSenderFactory().wrap(sender); List arguments = CommandManager.stripQuotes(TAB_COMPLETE_ARGUMENT_SPLITTER.splitToList(ARGUMENT_JOINER.join(args))); - return manager.onTabComplete(lpSender, arguments); + return this.manager.onTabComplete(lpSender, arguments); } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeConfigAdapter.java b/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeConfigAdapter.java index aa2cb2b2a..47313d0ce 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeConfigAdapter.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeConfigAdapter.java @@ -55,7 +55,7 @@ public class BungeeConfigAdapter extends AbstractConfigurationAdapter implements @Override public void reload() { try { - configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(file); + this.configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(this.file); } catch (IOException e) { throw new RuntimeException(e); } @@ -63,32 +63,32 @@ public class BungeeConfigAdapter extends AbstractConfigurationAdapter implements @Override public boolean contains(String path) { - return configuration.contains(path); + return this.configuration.contains(path); } @Override public String getString(String path, String def) { - return configuration.getString(path, def); + return this.configuration.getString(path, def); } @Override public int getInt(String path, int def) { - return configuration.getInt(path, def); + return this.configuration.getInt(path, def); } @Override public boolean getBoolean(String path, boolean def) { - return configuration.getBoolean(path, def); + return this.configuration.getBoolean(path, def); } @Override public List getList(String path, List def) { - return Optional.ofNullable(configuration.getStringList(path)).orElse(def); + return Optional.ofNullable(this.configuration.getStringList(path)).orElse(def); } @Override public List getObjectList(String path, List def) { - Configuration section = configuration.getSection(path); + Configuration section = this.configuration.getSection(path); if (section == null) { return def; } @@ -99,7 +99,7 @@ public class BungeeConfigAdapter extends AbstractConfigurationAdapter implements @Override public Map getMap(String path, Map def) { Map map = new HashMap<>(); - Configuration section = configuration.getSection(path); + Configuration section = this.configuration.getSection(path); if (section == null) { return def; } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeSchedulerAdapter.java b/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeSchedulerAdapter.java index f747a0725..40c939999 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeSchedulerAdapter.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/BungeeSchedulerAdapter.java @@ -47,17 +47,17 @@ public class BungeeSchedulerAdapter implements SchedulerAdapter { @Override public Executor async() { - return asyncExecutor; + return this.asyncExecutor; } @Override public Executor sync() { - return asyncExecutor; + return this.asyncExecutor; } @Override public void doAsync(Runnable runnable) { - asyncExecutor.execute(runnable); + this.asyncExecutor.execute(runnable); } @Override @@ -68,8 +68,8 @@ public class BungeeSchedulerAdapter implements SchedulerAdapter { @Override public void asyncRepeating(Runnable runnable, long intervalTicks) { long millis = intervalTicks * 50L; // convert from ticks to milliseconds - ScheduledTask task = plugin.getProxy().getScheduler().schedule(plugin, runnable, millis, millis, TimeUnit.MILLISECONDS); - tasks.add(task); + ScheduledTask task = this.plugin.getProxy().getScheduler().schedule(this.plugin, runnable, millis, millis, TimeUnit.MILLISECONDS); + this.tasks.add(task); } @Override @@ -80,7 +80,7 @@ public class BungeeSchedulerAdapter implements SchedulerAdapter { @Override public void asyncLater(Runnable runnable, long delayTicks) { long millis = delayTicks * 50L; // convert from ticks to milliseconds - plugin.getProxy().getScheduler().schedule(plugin, runnable, millis, TimeUnit.MILLISECONDS); + this.plugin.getProxy().getScheduler().schedule(this.plugin, runnable, millis, TimeUnit.MILLISECONDS); } @Override @@ -90,6 +90,6 @@ public class BungeeSchedulerAdapter implements SchedulerAdapter { @Override public void shutdown() { - tasks.forEach(ScheduledTask::cancel); + this.tasks.forEach(ScheduledTask::cancel); } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java b/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java index 4820079af..692b02424 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/LPBungeePlugin.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bungee; -import lombok.Getter; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.platform.PlatformType; import me.lucko.luckperms.bungee.calculators.BungeeCalculatorFactory; @@ -97,7 +95,6 @@ import java.util.stream.Stream; /** * LuckPerms implementation for the BungeeCord API. */ -@Getter public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { private long startTime; @@ -129,93 +126,93 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { @Override public void onLoad() { // setup minimal functionality in order to load initial dependencies - scheduler = new BungeeSchedulerAdapter(this); - localeManager = new NoopLocaleManager(); - senderFactory = new BungeeSenderFactory(this); - log = new SenderLogger(this, getConsoleSender()); + this.scheduler = new BungeeSchedulerAdapter(this); + this.localeManager = new NoopLocaleManager(); + this.senderFactory = new BungeeSenderFactory(this); + this.log = new SenderLogger(this, getConsoleSender()); - dependencyManager = new DependencyManager(this); - dependencyManager.loadDependencies(Collections.singleton(Dependency.CAFFEINE)); + this.dependencyManager = new DependencyManager(this); + this.dependencyManager.loadDependencies(Collections.singleton(Dependency.CAFFEINE)); } @Override public void onEnable() { - startTime = System.currentTimeMillis(); + this.startTime = System.currentTimeMillis(); sendStartupBanner(getConsoleSender()); - verboseHandler = new VerboseHandler(scheduler.async(), getVersion()); - permissionVault = new PermissionVault(scheduler.async()); - logDispatcher = new LogDispatcher(this); + this.verboseHandler = new VerboseHandler(this.scheduler.async(), getVersion()); + this.permissionVault = new PermissionVault(this.scheduler.async()); + this.logDispatcher = new LogDispatcher(this); getLog().info("Loading configuration..."); - configuration = new AbstractConfiguration(this, new BungeeConfigAdapter(this, resolveConfig("config.yml"))); - configuration.loadAll(); + this.configuration = new AbstractConfiguration(this, new BungeeConfigAdapter(this, resolveConfig("config.yml"))); + this.configuration.loadAll(); StorageFactory storageFactory = new StorageFactory(this); Set storageTypes = storageFactory.getRequiredTypes(StorageType.H2); - dependencyManager.loadStorageDependencies(storageTypes); + this.dependencyManager.loadStorageDependencies(storageTypes); // register events getProxy().getPluginManager().registerListener(this, new BungeeConnectionListener(this)); getProxy().getPluginManager().registerListener(this, new BungeePermissionCheckListener(this)); if (getConfiguration().get(ConfigKeys.WATCH_FILES)) { - fileWatcher = new FileWatcher(this); - getScheduler().asyncRepeating(fileWatcher, 30L); + this.fileWatcher = new FileWatcher(this); + getScheduler().asyncRepeating(this.fileWatcher, 30L); } // initialise datastore - storage = storageFactory.getInstance(StorageType.H2); + this.storage = storageFactory.getInstance(StorageType.H2); // initialise messaging - messagingService = new BungeeMessagingFactory(this).getInstance(); + this.messagingService = new BungeeMessagingFactory(this).getInstance(); // setup the update task buffer - updateTaskBuffer = new UpdateTaskBuffer(this); + this.updateTaskBuffer = new UpdateTaskBuffer(this); // load locale - localeManager = new SimpleLocaleManager(); - localeManager.tryLoad(this, new File(getDataFolder(), "lang.yml")); + this.localeManager = new SimpleLocaleManager(); + this.localeManager.tryLoad(this, new File(getDataFolder(), "lang.yml")); // register commands - commandManager = new CommandManager(this); - getProxy().getPluginManager().registerCommand(this, new BungeeCommandExecutor(this, commandManager)); + this.commandManager = new CommandManager(this); + getProxy().getPluginManager().registerCommand(this, new BungeeCommandExecutor(this, this.commandManager)); // disable the default Bungee /perms command so it gets handled by the Bukkit plugin getProxy().getDisabledCommands().add("perms"); // load internal managers getLog().info("Loading internal permission managers..."); - uuidCache = new UuidCache(this); - userManager = new GenericUserManager(this); - groupManager = new GenericGroupManager(this); - trackManager = new GenericTrackManager(this); - calculatorFactory = new BungeeCalculatorFactory(this); - cachedStateManager = new CachedStateManager(); + this.uuidCache = new UuidCache(this); + this.userManager = new GenericUserManager(this); + this.groupManager = new GenericGroupManager(this); + this.trackManager = new GenericTrackManager(this); + this.calculatorFactory = new BungeeCalculatorFactory(this); + this.cachedStateManager = new CachedStateManager(); // setup context manager - contextManager = new BungeeContextManager(this); - contextManager.registerCalculator(new BackendServerCalculator(this)); - contextManager.registerStaticCalculator(new LuckPermsCalculator(getConfiguration())); + this.contextManager = new BungeeContextManager(this); + this.contextManager.registerCalculator(new BackendServerCalculator(this)); + this.contextManager.registerStaticCalculator(new LuckPermsCalculator(getConfiguration())); if (getProxy().getPluginManager().getPlugin("RedisBungee") != null) { - contextManager.registerStaticCalculator(new RedisBungeeCalculator()); + this.contextManager.registerStaticCalculator(new RedisBungeeCalculator()); } // register with the LP API - apiProvider = new LuckPermsApiProvider(this); + this.apiProvider = new LuckPermsApiProvider(this); // setup event factory - eventFactory = new EventFactory(this, apiProvider); + this.eventFactory = new EventFactory(this, this.apiProvider); - ApiRegistrationUtil.registerProvider(apiProvider); + ApiRegistrationUtil.registerProvider(this.apiProvider); // schedule update tasks int mins = getConfiguration().get(ConfigKeys.SYNC_TIME); if (mins > 0) { long ticks = mins * 60 * 20; - scheduler.asyncRepeating(() -> updateTaskBuffer.request(), ticks); + this.scheduler.asyncRepeating(() -> this.updateTaskBuffer.request(), ticks); } - scheduler.asyncLater(() -> updateTaskBuffer.request(), 40L); + this.scheduler.asyncLater(() -> this.updateTaskBuffer.request(), 40L); // run an update instantly. getLog().info("Performing initial data load..."); @@ -227,33 +224,33 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { // register tasks - scheduler.asyncRepeating(new ExpireTemporaryTask(this), 60L); - scheduler.asyncRepeating(new CacheHousekeepingTask(this), 2400L); + this.scheduler.asyncRepeating(new ExpireTemporaryTask(this), 60L); + this.scheduler.asyncRepeating(new CacheHousekeepingTask(this), 2400L); - getLog().info("Successfully enabled. (took " + (System.currentTimeMillis() - startTime) + "ms)"); + getLog().info("Successfully enabled. (took " + (System.currentTimeMillis() - this.startTime) + "ms)"); } @Override public void onDisable() { - permissionVault.shutdown(); - verboseHandler.shutdown(); + this.permissionVault.shutdown(); + this.verboseHandler.shutdown(); getLog().info("Closing storage..."); - storage.shutdown(); + this.storage.shutdown(); - if (fileWatcher != null) { - fileWatcher.close(); + if (this.fileWatcher != null) { + this.fileWatcher.close(); } - if (messagingService != null) { + if (this.messagingService != null) { getLog().info("Closing messaging service..."); - messagingService.close(); + this.messagingService.close(); } ApiRegistrationUtil.unregisterProvider(); getLog().info("Shutting down internal scheduler..."); - scheduler.shutdown(); + this.scheduler.shutdown(); getProxy().getScheduler().cancel(this); getProxy().getPluginManager().unregisterListeners(this); @@ -277,11 +274,12 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { @Override public Optional getMessagingService() { - return Optional.ofNullable(messagingService); + return Optional.ofNullable(this.messagingService); } + @Override public Optional getFileWatcher() { - return Optional.ofNullable(fileWatcher); + return Optional.ofNullable(this.fileWatcher); } @Override @@ -316,7 +314,7 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { @Override public ProxiedPlayer getPlayer(User user) { - return getProxy().getPlayer(uuidCache.getExternalUUID(user.getUuid())); + return getProxy().getPlayer(this.uuidCache.getExternalUUID(user.getUuid())); } @Override @@ -338,7 +336,7 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { if (player == null) { return null; } - return contextManager.getApplicableContexts(player); + return this.contextManager.getApplicableContexts(player); } @Override @@ -374,4 +372,118 @@ public class LPBungeePlugin extends Plugin implements LuckPermsPlugin { public Sender getConsoleSender() { return getSenderFactory().wrap(getProxy().getConsole()); } + + @Override + public long getStartTime() { + return this.startTime; + } + + @Override + public SchedulerAdapter getScheduler() { + return this.scheduler; + } + + @Override + public CommandManager getCommandManager() { + return this.commandManager; + } + + @Override + public LuckPermsConfiguration getConfiguration() { + return this.configuration; + } + + @Override + public UserManager getUserManager() { + return this.userManager; + } + + @Override + public GroupManager getGroupManager() { + return this.groupManager; + } + + @Override + public TrackManager getTrackManager() { + return this.trackManager; + } + + @Override + public Storage getStorage() { + return this.storage; + } + + @Override + public UuidCache getUuidCache() { + return this.uuidCache; + } + + @Override + public LuckPermsApiProvider getApiProvider() { + return this.apiProvider; + } + + @Override + public EventFactory getEventFactory() { + return this.eventFactory; + } + + @Override + public Logger getLog() { + return this.log; + } + + @Override + public LocaleManager getLocaleManager() { + return this.localeManager; + } + + @Override + public DependencyManager getDependencyManager() { + return this.dependencyManager; + } + + @Override + public CachedStateManager getCachedStateManager() { + return this.cachedStateManager; + } + + @Override + public ContextManager getContextManager() { + return this.contextManager; + } + + @Override + public CalculatorFactory getCalculatorFactory() { + return this.calculatorFactory; + } + + @Override + public BufferedRequest getUpdateTaskBuffer() { + return this.updateTaskBuffer; + } + + @Override + public VerboseHandler getVerboseHandler() { + return this.verboseHandler; + } + + public BungeeSenderFactory getSenderFactory() { + return this.senderFactory; + } + + @Override + public PermissionVault getPermissionVault() { + return this.permissionVault; + } + + @Override + public LogDispatcher getLogDispatcher() { + return this.logDispatcher; + } + + @Override + public Set getUniqueConnections() { + return this.uniqueConnections; + } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/calculators/BungeeCalculatorFactory.java b/bungee/src/main/java/me/lucko/luckperms/bungee/calculators/BungeeCalculatorFactory.java index 283cf7352..e95ef2fa5 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/calculators/BungeeCalculatorFactory.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/calculators/BungeeCalculatorFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bungee.calculators; -import lombok.AllArgsConstructor; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.Contexts; @@ -42,33 +40,36 @@ import me.lucko.luckperms.common.processors.WildcardProcessor; import java.util.List; -@AllArgsConstructor public class BungeeCalculatorFactory extends AbstractCalculatorFactory { private final LPBungeePlugin plugin; + public BungeeCalculatorFactory(LPBungeePlugin plugin) { + this.plugin = plugin; + } + @Override public PermissionCalculator build(Contexts contexts, PermissionCalculatorMetadata metadata) { ImmutableList.Builder processors = ImmutableList.builder(); processors.add(new MapProcessor()); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { processors.add(new RegexProcessor()); } - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { processors.add(new WildcardProcessor()); } - return registerCalculator(new PermissionCalculator(plugin, metadata, processors.build())); + return registerCalculator(new PermissionCalculator(this.plugin, metadata, processors.build())); } @Override public List getActiveProcessors() { ImmutableList.Builder ret = ImmutableList.builder(); ret.add("Map"); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) ret.add("Regex"); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) ret.add("Wildcards"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) ret.add("Regex"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) ret.add("Wildcards"); return ret.build(); } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BackendServerCalculator.java b/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BackendServerCalculator.java index 8b1061ec4..95cba2d25 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BackendServerCalculator.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BackendServerCalculator.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bungee.contexts; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.context.ContextCalculator; import me.lucko.luckperms.api.context.MutableContextSet; @@ -35,7 +33,8 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import net.md_5.bungee.api.connection.ProxiedPlayer; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class BackendServerCalculator implements ContextCalculator { private static String getServer(ProxiedPlayer player) { @@ -44,12 +43,17 @@ public class BackendServerCalculator implements ContextCalculator private final LuckPermsPlugin plugin; + public BackendServerCalculator(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + @Nonnull @Override - public MutableContextSet giveApplicableContext(ProxiedPlayer subject, MutableContextSet accumulator) { + public MutableContextSet giveApplicableContext(@Nonnull ProxiedPlayer subject, @Nonnull MutableContextSet accumulator) { String server = getServer(subject); while (server != null && !accumulator.has(Contexts.WORLD_KEY, server)) { accumulator.add(Contexts.WORLD_KEY, server); - server = plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(server, server).toLowerCase(); + server = this.plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(server, server).toLowerCase(); } return accumulator; diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BungeeContextManager.java b/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BungeeContextManager.java index 028e05ef4..7330f81b4 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BungeeContextManager.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/BungeeContextManager.java @@ -42,11 +42,11 @@ public class BungeeContextManager extends AbstractContextManager public Contexts formContexts(ProxiedPlayer subject, ImmutableContextSet contextSet) { return new Contexts( contextSet, - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), true, - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), false ); } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/RedisBungeeCalculator.java b/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/RedisBungeeCalculator.java index 574963a80..30e239d39 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/RedisBungeeCalculator.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/contexts/RedisBungeeCalculator.java @@ -31,11 +31,14 @@ import com.imaginarycode.minecraft.redisbungee.RedisBungeeAPI; import me.lucko.luckperms.api.context.MutableContextSet; import me.lucko.luckperms.api.context.StaticContextCalculator; +import javax.annotation.Nonnull; + public class RedisBungeeCalculator implements StaticContextCalculator { private static final String PROXY_KEY = "proxy"; + @Nonnull @Override - public MutableContextSet giveApplicableContext(MutableContextSet accumulator) { + public MutableContextSet giveApplicableContext(@Nonnull MutableContextSet accumulator) { RedisBungeeAPI redisBungee = RedisBungee.getApi(); if (redisBungee != null) { accumulator.add(PROXY_KEY, redisBungee.getServerId()); diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/event/TristateCheckEvent.java b/bungee/src/main/java/me/lucko/luckperms/bungee/event/TristateCheckEvent.java index e36a67a90..4b707b211 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/event/TristateCheckEvent.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/event/TristateCheckEvent.java @@ -25,12 +25,6 @@ package me.lucko.luckperms.bungee.event; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.Setter; -import lombok.ToString; - import me.lucko.luckperms.api.Tristate; import net.md_5.bungee.api.CommandSender; @@ -40,10 +34,6 @@ import net.md_5.bungee.api.plugin.Event; /** * Copy of the internal BungeeCord "PermissionCheckEvent", returning a tristate instead of a boolean. */ -@Getter -@AllArgsConstructor -@EqualsAndHashCode(callSuper = false) -@ToString public class TristateCheckEvent extends Event { public static Tristate call(CommandSender sender, String permission) { return ProxyServer.getInstance().getPluginManager().callEvent(new TristateCheckEvent(sender, permission)).getResult(); @@ -52,11 +42,40 @@ public class TristateCheckEvent extends Event { private final CommandSender sender; private final String permission; - @Setter private Tristate result; public TristateCheckEvent(CommandSender sender, String permission) { this(sender, permission, sender.getPermissions().contains(permission) ? Tristate.TRUE : Tristate.UNDEFINED); } + public TristateCheckEvent(CommandSender sender, String permission, Tristate result) { + this.sender = sender; + this.permission = permission; + this.result = result; + } + + public CommandSender getSender() { + return this.sender; + } + + public String getPermission() { + return this.permission; + } + + public Tristate getResult() { + return this.result; + } + + public void setResult(Tristate result) { + this.result = result; + } + + @Override + public String toString() { + return "TristateCheckEvent(" + + "sender=" + this.sender + ", " + + "permission=" + this.permission + ", " + + "result=" + this.result + ")"; + } + } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeeConnectionListener.java b/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeeConnectionListener.java index e09ce31c6..1d06011ef 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeeConnectionListener.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeeConnectionListener.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bungee.listeners; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.bungee.LPBungeePlugin; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.locale.Message; @@ -45,10 +43,13 @@ import net.md_5.bungee.event.EventPriority; import java.util.concurrent.TimeUnit; -@RequiredArgsConstructor public class BungeeConnectionListener implements Listener { private final LPBungeePlugin plugin; + public BungeeConnectionListener(LPBungeePlugin plugin) { + this.plugin = plugin; + } + @EventHandler(priority = EventPriority.LOW) public void onPlayerLogin(LoginEvent e) { /* Called when the player first attempts a connection with the server. @@ -60,16 +61,16 @@ public class BungeeConnectionListener implements Listener { /* registers the plugins intent to modify this events state going forward. this will prevent the event from completing until we're finished handling. */ - e.registerIntent(plugin); + e.registerIntent(this.plugin); final PendingConnection c = e.getConnection(); - if (plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { - plugin.getLog().info("Processing pre-login for " + c.getUniqueId() + " - " + c.getName()); + if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { + this.plugin.getLog().info("Processing pre-login for " + c.getUniqueId() + " - " + c.getName()); } - plugin.getScheduler().doAsync(() -> { - plugin.getUniqueConnections().add(c.getUniqueId()); + this.plugin.getScheduler().doAsync(() -> { + this.plugin.getUniqueConnections().add(c.getUniqueId()); /* Actually process the login for the connection. We do this here to delay the login until the data is ready. @@ -81,51 +82,51 @@ public class BungeeConnectionListener implements Listener { - creating a user instance in the UserManager for this connection. - setting up cached data. */ try { - User user = LoginHelper.loadUser(plugin, c.getUniqueId(), c.getName(), true); - plugin.getEventFactory().handleUserLoginProcess(c.getUniqueId(), c.getName(), user); + User user = LoginHelper.loadUser(this.plugin, c.getUniqueId(), c.getName(), true); + this.plugin.getEventFactory().handleUserLoginProcess(c.getUniqueId(), c.getName(), user); } catch (Exception ex) { - plugin.getLog().severe("Exception occured whilst loading data for " + c.getUniqueId() + " - " + c.getName()); + this.plugin.getLog().severe("Exception occured whilst loading data for " + c.getUniqueId() + " - " + c.getName()); ex.printStackTrace(); // there was some error loading - if (plugin.getConfiguration().get(ConfigKeys.CANCEL_FAILED_LOGINS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.CANCEL_FAILED_LOGINS)) { // cancel the login attempt - e.setCancelReason(TextComponent.fromLegacyText(Message.LOADING_ERROR.asString(plugin.getLocaleManager()))); + e.setCancelReason(TextComponent.fromLegacyText(Message.LOADING_ERROR.asString(this.plugin.getLocaleManager()))); e.setCancelled(true); } } // finally, complete our intent to modify state, so the proxy can continue handling the connection. - e.completeIntent(plugin); + e.completeIntent(this.plugin); // schedule a cleanup of the users data in a few seconds. // this should cover the eventuality that the login fails. - plugin.getUserManager().scheduleUnload(c.getUniqueId()); + this.plugin.getUserManager().scheduleUnload(c.getUniqueId()); }); } @EventHandler public void onPlayerPostLogin(PostLoginEvent e) { final ProxiedPlayer player = e.getPlayer(); - final User user = plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId())); + final User user = this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(e.getPlayer().getUniqueId())); - if (plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { - plugin.getLog().info("Processing post-login for " + player.getUniqueId() + " - " + player.getName()); + if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { + this.plugin.getLog().info("Processing post-login for " + player.getUniqueId() + " - " + player.getName()); } if (user == null) { - if (plugin.getConfiguration().get(ConfigKeys.CANCEL_FAILED_LOGINS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.CANCEL_FAILED_LOGINS)) { // disconnect the user - plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded - cancelling login."); - e.getPlayer().disconnect(TextComponent.fromLegacyText(Message.LOADING_ERROR.asString(plugin.getLocaleManager()))); + this.plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded - cancelling login."); + e.getPlayer().disconnect(TextComponent.fromLegacyText(Message.LOADING_ERROR.asString(this.plugin.getLocaleManager()))); } else { // just send a message - plugin.getProxy().getScheduler().schedule(plugin, () -> { + this.plugin.getProxy().getScheduler().schedule(this.plugin, () -> { if (!player.isConnected()) { return; } - player.sendMessage(TextComponent.fromLegacyText(Message.LOADING_ERROR.asString(plugin.getLocaleManager()))); + player.sendMessage(TextComponent.fromLegacyText(Message.LOADING_ERROR.asString(this.plugin.getLocaleManager()))); }, 1, TimeUnit.SECONDS); } } @@ -135,7 +136,7 @@ public class BungeeConnectionListener implements Listener { @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerQuit(PlayerDisconnectEvent e) { // Request that the users data is unloaded. - plugin.getUserManager().scheduleUnload(e.getPlayer().getUniqueId()); + this.plugin.getUserManager().scheduleUnload(e.getPlayer().getUniqueId()); } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeePermissionCheckListener.java b/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeePermissionCheckListener.java index f5996ae1f..1a82e2c17 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeePermissionCheckListener.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/listeners/BungeePermissionCheckListener.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.bungee.listeners; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.bungee.LPBungeePlugin; @@ -41,10 +39,13 @@ import net.md_5.bungee.api.plugin.Listener; import net.md_5.bungee.event.EventHandler; import net.md_5.bungee.event.EventPriority; -@RequiredArgsConstructor public class BungeePermissionCheckListener implements Listener { private final LPBungeePlugin plugin; + public BungeePermissionCheckListener(LPBungeePlugin plugin) { + this.plugin = plugin; + } + @EventHandler(priority = EventPriority.HIGH) public void onPlayerPermissionCheck(PermissionCheckEvent e) { if (!(e.getSender() instanceof ProxiedPlayer)) { @@ -53,15 +54,15 @@ public class BungeePermissionCheckListener implements Listener { ProxiedPlayer player = ((ProxiedPlayer) e.getSender()); - User user = plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(player.getUniqueId())); + User user = this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(player.getUniqueId())); if (user == null) { e.setHasPermission(false); return; } - Contexts contexts = plugin.getContextManager().getApplicableContexts(player); + Contexts contexts = this.plugin.getContextManager().getApplicableContexts(player); Tristate result = user.getCachedData().getPermissionData(contexts).getPermissionValue(e.getPermission(), CheckOrigin.PLATFORM_PERMISSION_CHECK); - if (result == Tristate.UNDEFINED && plugin.getConfiguration().get(ConfigKeys.APPLY_BUNGEE_CONFIG_PERMISSIONS)) { + if (result == Tristate.UNDEFINED && this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUNGEE_CONFIG_PERMISSIONS)) { return; // just use the result provided by the proxy when the event was created } @@ -76,15 +77,15 @@ public class BungeePermissionCheckListener implements Listener { ProxiedPlayer player = ((ProxiedPlayer) e.getSender()); - User user = plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(player.getUniqueId())); + User user = this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(player.getUniqueId())); if (user == null) { e.setResult(Tristate.UNDEFINED); return; } - Contexts contexts = plugin.getContextManager().getApplicableContexts(player); + Contexts contexts = this.plugin.getContextManager().getApplicableContexts(player); Tristate result = user.getCachedData().getPermissionData(contexts).getPermissionValue(e.getPermission(), CheckOrigin.PLATFORM_LOOKUP_CHECK); - if (result == Tristate.UNDEFINED && plugin.getConfiguration().get(ConfigKeys.APPLY_BUNGEE_CONFIG_PERMISSIONS)) { + if (result == Tristate.UNDEFINED && this.plugin.getConfiguration().get(ConfigKeys.APPLY_BUNGEE_CONFIG_PERMISSIONS)) { return; // just use the result provided by the proxy when the event was created } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/BungeeMessagingService.java b/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/BungeeMessagingService.java index 34079111d..3a79069b2 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/BungeeMessagingService.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/BungeeMessagingService.java @@ -51,13 +51,13 @@ public class BungeeMessagingService extends AbstractMessagingService implements } public void init() { - plugin.getProxy().getPluginManager().registerListener(plugin, this); - plugin.getProxy().registerChannel(CHANNEL); + this.plugin.getProxy().getPluginManager().registerListener(this.plugin, this); + this.plugin.getProxy().registerChannel(CHANNEL); } @Override public void close() { - plugin.getProxy().unregisterChannel(CHANNEL); + this.plugin.getProxy().unregisterChannel(CHANNEL); } @Override @@ -68,7 +68,7 @@ public class BungeeMessagingService extends AbstractMessagingService implements byte[] data = out.toByteArray(); - for (ServerInfo server : plugin.getProxy().getServers().values()) { + for (ServerInfo server : this.plugin.getProxy().getServers().values()) { server.sendData(CHANNEL, data, true); } } @@ -90,7 +90,7 @@ public class BungeeMessagingService extends AbstractMessagingService implements onMessage(msg, u -> { // Forward to other servers - plugin.getScheduler().doAsync(() -> sendMessage(u)); + this.plugin.getScheduler().doAsync(() -> sendMessage(u)); }); } } diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/RedisBungeeMessagingService.java b/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/RedisBungeeMessagingService.java index 3c02dad83..30d3a9aee 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/RedisBungeeMessagingService.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/messaging/RedisBungeeMessagingService.java @@ -50,22 +50,22 @@ public class RedisBungeeMessagingService extends AbstractMessagingService implem public void init() { this.redisBungee = RedisBungee.getApi(); - redisBungee.registerPubSubChannels(CHANNEL); + this.redisBungee.registerPubSubChannels(CHANNEL); - plugin.getProxy().getPluginManager().registerListener(plugin, this); + this.plugin.getProxy().getPluginManager().registerListener(this.plugin, this); } @Override public void close() { - redisBungee.unregisterPubSubChannels(CHANNEL); - redisBungee = null; + this.redisBungee.unregisterPubSubChannels(CHANNEL); + this.redisBungee = null; - plugin.getProxy().getPluginManager().unregisterListener(this); + this.plugin.getProxy().getPluginManager().unregisterListener(this); } @Override protected void sendMessage(String message) { - redisBungee.sendChannelMessage(CHANNEL, message); + this.redisBungee.sendChannelMessage(CHANNEL, message); } @EventHandler diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/migration/MigrationBungeePerms.java b/bungee/src/main/java/me/lucko/luckperms/bungee/migration/MigrationBungeePerms.java index 1facb1dfc..377d5cd60 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/migration/MigrationBungeePerms.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/migration/MigrationBungeePerms.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.bungee.migration; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -57,7 +56,7 @@ public class MigrationBungeePerms extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("BungeePerms"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/bungee/src/main/java/me/lucko/luckperms/bungee/util/RedisBungeeUtil.java b/bungee/src/main/java/me/lucko/luckperms/bungee/util/RedisBungeeUtil.java index fae1cf494..140f6fd5d 100644 --- a/bungee/src/main/java/me/lucko/luckperms/bungee/util/RedisBungeeUtil.java +++ b/bungee/src/main/java/me/lucko/luckperms/bungee/util/RedisBungeeUtil.java @@ -25,15 +25,12 @@ package me.lucko.luckperms.bungee.util; -import lombok.experimental.UtilityClass; - import com.imaginarycode.minecraft.redisbungee.RedisBungee; import java.util.Optional; import java.util.UUID; -@UtilityClass -public class RedisBungeeUtil { +public final class RedisBungeeUtil { /** * Looks up a UUID from username via RedisBungee's uuid cache. @@ -45,4 +42,6 @@ public class RedisBungeeUtil { return Optional.ofNullable(RedisBungee.getApi()).flatMap(a -> Optional.ofNullable(a.getUuidFromName(username, true))); } + private RedisBungeeUtil() {} + } diff --git a/common/pom.xml b/common/pom.xml index 67f03e48c..00c2468bc 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -153,11 +153,10 @@ 2.6.0 provided - - org.projectlombok - lombok - ${lombok.version} + com.google.code.findbugs + jsr305 + 3.0.2 provided diff --git a/common/src/main/java/me/lucko/luckperms/common/actionlog/ExtendedLogEntry.java b/common/src/main/java/me/lucko/luckperms/common/actionlog/ExtendedLogEntry.java index f2976e8cd..1e779ce9e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/actionlog/ExtendedLogEntry.java +++ b/common/src/main/java/me/lucko/luckperms/common/actionlog/ExtendedLogEntry.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.common.actionlog; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.ToString; - -import com.google.common.base.Preconditions; import com.google.common.base.Strings; import com.google.common.collect.Maps; import com.google.gson.JsonObject; @@ -50,16 +45,18 @@ import java.util.ArrayList; import java.util.Comparator; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.UUID; import java.util.stream.Collectors; +import javax.annotation.Nonnull; + /** * An implementation of {@link LogEntry} and {@link LogEntry.Builder}, * with helper methods for populating and using the entry using internal * LuckPerms classes. */ -@AllArgsConstructor(access = AccessLevel.PRIVATE) public class ExtendedLogEntry implements LogEntry { private static final Comparator COMPARATOR = Comparator @@ -88,68 +85,84 @@ public class ExtendedLogEntry implements LogEntry { private final String actedName; private final String action; + private ExtendedLogEntry(long timestamp, UUID actor, String actorName, Type type, UUID acted, String actedName, String action) { + this.timestamp = timestamp; + this.actor = actor; + this.actorName = actorName; + this.type = type; + this.acted = acted; + this.actedName = actedName; + this.action = action; + } + @Override public long getTimestamp() { - return timestamp; + return this.timestamp; } + @Nonnull @Override public UUID getActor() { - return actor; + return this.actor; } + @Nonnull @Override public String getActorName() { - return actorName; + return this.actorName; } public String getActorFriendlyString() { - if (Strings.isNullOrEmpty(actorName) || actorName.equals("null")) { - return actor.toString(); + if (Strings.isNullOrEmpty(this.actorName) || this.actorName.equals("null")) { + return this.actor.toString(); } - return actorName; + return this.actorName; } + @Nonnull @Override public Type getType() { - return type; + return this.type; } + @Nonnull @Override public Optional getActed() { - return Optional.ofNullable(acted); + return Optional.ofNullable(this.acted); } + @Nonnull @Override public String getActedName() { - return actedName; + return this.actedName; } public String getActedFriendlyString() { - if (Strings.isNullOrEmpty(actedName) || actedName.equals("null")) { - if (acted != null) { - return acted.toString(); + if (Strings.isNullOrEmpty(this.actedName) || this.actedName.equals("null")) { + if (this.acted != null) { + return this.acted.toString(); } } - return String.valueOf(actedName); + return String.valueOf(this.actedName); } + @Nonnull @Override public String getAction() { - return action; + return this.action; } @Override - public int compareTo(LogEntry other) { - Preconditions.checkNotNull(other, "other"); + public int compareTo(@Nonnull LogEntry other) { + Objects.requireNonNull(other, "other"); return COMPARATOR.compare(this, other); } public boolean matchesSearch(String query) { - query = Preconditions.checkNotNull(query, "query").toLowerCase(); - return actorName.toLowerCase().contains(query) || - actedName.toLowerCase().contains(query) || - action.toLowerCase().contains(query); + query = Objects.requireNonNull(query, "query").toLowerCase(); + return this.actorName.toLowerCase().contains(query) || + this.actedName.toLowerCase().contains(query) || + this.action.toLowerCase().contains(query); } public void submit(LuckPermsPlugin plugin, Sender sender) { @@ -172,15 +185,15 @@ public class ExtendedLogEntry implements LogEntry { public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof LogEntry)) return false; - final LogEntry other = (LogEntry) o; + final LogEntry that = (LogEntry) o; - return this.getTimestamp() == other.getTimestamp() && - this.getActor().equals(other.getActor()) && - this.getActorName().equals(other.getActorName()) && - this.getType() == other.getType() && - this.getActed().equals(other.getActed()) && - this.getActedName().equals(other.getActedName()) && - this.getAction().equals(other.getAction()); + return this.getTimestamp() == that.getTimestamp() && + this.getActor().equals(that.getActor()) && + this.getActorName().equals(that.getActorName()) && + this.getType() == that.getType() && + this.getActed().equals(that.getActed()) && + this.getActedName().equals(that.getActedName()) && + this.getAction().equals(that.getAction()); } @Override @@ -197,7 +210,6 @@ public class ExtendedLogEntry implements LogEntry { return result; } - @ToString public static class ExtendedLogEntryBuilder implements LogEntry.Builder { private long timestamp = 0L; @@ -208,45 +220,52 @@ public class ExtendedLogEntry implements LogEntry { private String actedName = null; private String action = null; + @Nonnull @Override public ExtendedLogEntryBuilder setTimestamp(long timestamp) { this.timestamp = timestamp; return this; } + @Nonnull @Override - public ExtendedLogEntryBuilder setActor(UUID actor) { - this.actor = Preconditions.checkNotNull(actor, "actor"); + public ExtendedLogEntryBuilder setActor(@Nonnull UUID actor) { + this.actor = Objects.requireNonNull(actor, "actor"); return this; } + @Nonnull @Override - public ExtendedLogEntryBuilder setActorName(String actorName) { - this.actorName = Preconditions.checkNotNull(actorName, "actorName"); + public ExtendedLogEntryBuilder setActorName(@Nonnull String actorName) { + this.actorName = Objects.requireNonNull(actorName, "actorName"); return this; } + @Nonnull @Override - public ExtendedLogEntryBuilder setType(Type type) { - this.type = Preconditions.checkNotNull(type, "type"); + public ExtendedLogEntryBuilder setType(@Nonnull Type type) { + this.type = Objects.requireNonNull(type, "type"); return this; } + @Nonnull @Override public ExtendedLogEntryBuilder setActed(UUID acted) { this.acted = acted; // nullable return this; } + @Nonnull @Override - public ExtendedLogEntryBuilder setActedName(String actedName) { - this.actedName = Preconditions.checkNotNull(actedName, "actedName"); + public ExtendedLogEntryBuilder setActedName(@Nonnull String actedName) { + this.actedName = Objects.requireNonNull(actedName, "actedName"); return this; } + @Nonnull @Override - public ExtendedLogEntryBuilder setAction(String action) { - this.action = Preconditions.checkNotNull(action, "action"); + public ExtendedLogEntryBuilder setAction(@Nonnull String action) { + this.action = Objects.requireNonNull(action, "action"); return this; } @@ -333,19 +352,32 @@ public class ExtendedLogEntry implements LogEntry { return this; } + @Nonnull @Override public ExtendedLogEntry build() { - if (timestamp == 0L) { + if (this.timestamp == 0L) { timestamp(DateUtil.unixSecondsNow()); } - Preconditions.checkNotNull(actor, "actor"); - Preconditions.checkNotNull(actorName, "actorName"); - Preconditions.checkNotNull(type, "type"); - Preconditions.checkNotNull(actedName, "actedName"); - Preconditions.checkNotNull(action, "action"); + Objects.requireNonNull(this.actor, "actor"); + Objects.requireNonNull(this.actorName, "actorName"); + Objects.requireNonNull(this.type, "type"); + Objects.requireNonNull(this.actedName, "actedName"); + Objects.requireNonNull(this.action, "action"); - return new ExtendedLogEntry(timestamp, actor, actorName, type, acted, actedName, action); + return new ExtendedLogEntry(this.timestamp, this.actor, this.actorName, this.type, this.acted, this.actedName, this.action); + } + + @Override + public String toString() { + return "ExtendedLogEntry.ExtendedLogEntryBuilder(" + + "timestamp=" + this.timestamp + ", " + + "actor=" + this.actor + ", " + + "actorName=" + this.actorName + ", " + + "type=" + this.type + ", " + + "acted=" + this.acted + ", " + + "actedName=" + this.actedName + ", " + + "action=" + this.action + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/actionlog/Log.java b/common/src/main/java/me/lucko/luckperms/common/actionlog/Log.java index ec5942206..22d68095c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/actionlog/Log.java +++ b/common/src/main/java/me/lucko/luckperms/common/actionlog/Log.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.actionlog; -import lombok.Getter; - import com.google.common.collect.ImmutableSortedSet; import me.lucko.luckperms.api.LogEntry; @@ -77,7 +75,6 @@ public class Log { return (int) Math.ceil((double) size / (double) entries); } - @Getter private final SortedSet content; public Log(SortedSet content) { @@ -85,19 +82,19 @@ public class Log { } public SortedSet getRecent() { - return content; + return this.content; } public SortedMap getRecent(int pageNo, int entriesPerPage) { - return getPage(content, pageNo, entriesPerPage); + return getPage(this.content, pageNo, entriesPerPage); } public int getRecentMaxPages(int entriesPerPage) { - return getMaxPages(content.size(), entriesPerPage); + return getMaxPages(this.content.size(), entriesPerPage); } public SortedSet getRecent(UUID actor) { - return content.stream() + return this.content.stream() .filter(e -> e.getActor().equals(actor)) .collect(Collectors.toCollection(TreeSet::new)); } @@ -107,13 +104,13 @@ public class Log { } public int getRecentMaxPages(UUID actor, int entriesPerPage) { - return getMaxPages(content.stream() + return getMaxPages(this.content.stream() .filter(e -> e.getActor().equals(actor)) .mapToInt(x -> 1).sum(), entriesPerPage); } public SortedSet getUserHistory(UUID uuid) { - return content.stream() + return this.content.stream() .filter(e -> e.getType() == LogEntry.Type.USER) .filter(e -> e.getActed().isPresent()) .filter(e -> e.getActed().get().equals(uuid)) @@ -125,7 +122,7 @@ public class Log { } public int getUserHistoryMaxPages(UUID uuid, int entriesPerPage) { - return getMaxPages(content.stream() + return getMaxPages(this.content.stream() .filter(e -> e.getType() == LogEntry.Type.USER) .filter(e -> e.getActed().isPresent()) .filter(e -> e.getActed().get().equals(uuid)) @@ -133,7 +130,7 @@ public class Log { } public SortedSet getGroupHistory(String name) { - return content.stream() + return this.content.stream() .filter(e -> e.getType() == LogEntry.Type.GROUP) .filter(e -> e.getActedName().equals(name)) .collect(Collectors.toCollection(TreeSet::new)); @@ -144,14 +141,14 @@ public class Log { } public int getGroupHistoryMaxPages(String name, int entriesPerPage) { - return getMaxPages(content.stream() + return getMaxPages(this.content.stream() .filter(e -> e.getType() == LogEntry.Type.GROUP) .filter(e -> e.getActedName().equals(name)) .mapToInt(x -> 1).sum(), entriesPerPage); } public SortedSet getTrackHistory(String name) { - return content.stream() + return this.content.stream() .filter(e -> e.getType() == LogEntry.Type.TRACK) .filter(e -> e.getActedName().equals(name)) .collect(Collectors.toCollection(TreeSet::new)); @@ -162,14 +159,14 @@ public class Log { } public int getTrackHistoryMaxPages(String name, int entriesPerPage) { - return getMaxPages(content.stream() + return getMaxPages(this.content.stream() .filter(e -> e.getType() == LogEntry.Type.TRACK) .filter(e -> e.getActedName().equals(name)) .mapToInt(x -> 1).sum(), entriesPerPage); } public SortedSet getSearch(String query) { - return content.stream() + return this.content.stream() .filter(e -> e.matchesSearch(query)) .collect(Collectors.toCollection(TreeSet::new)); } @@ -179,22 +176,26 @@ public class Log { } public int getSearchMaxPages(String query, int entriesPerPage) { - return getMaxPages(content.stream() + return getMaxPages(this.content.stream() .filter(e -> e.matchesSearch(query)) .mapToInt(x -> 1).sum(), entriesPerPage); } + public SortedSet getContent() { + return this.content; + } + @SuppressWarnings("WeakerAccess") public static class Builder { private final SortedSet content = new TreeSet<>(); public Builder add(ExtendedLogEntry e) { - content.add(e); + this.content.add(e); return this; } public Log build() { - return new Log(content); + return new Log(this.content); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/actionlog/LogDispatcher.java b/common/src/main/java/me/lucko/luckperms/common/actionlog/LogDispatcher.java index c44429ffd..849ce50a8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/actionlog/LogDispatcher.java +++ b/common/src/main/java/me/lucko/luckperms/common/actionlog/LogDispatcher.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.actionlog; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.event.log.LogBroadcastEvent; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.impl.log.LogNotify; @@ -38,16 +36,19 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.Optional; -@RequiredArgsConstructor public class LogDispatcher { private final LuckPermsPlugin plugin; + public LogDispatcher(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + private void broadcast(ExtendedLogEntry entry, LogBroadcastEvent.Origin origin, Sender sender) { - plugin.getOnlineSenders() + this.plugin.getOnlineSenders() .filter(CommandPermission.LOG_NOTIFY::isAuthorized) .filter(s -> { - boolean shouldCancel = LogNotify.isIgnoring(plugin, s.getUuid()) || (sender != null && s.getUuid().equals(sender.getUuid())); - return !plugin.getEventFactory().handleLogNotify(shouldCancel, entry, origin, s); + boolean shouldCancel = LogNotify.isIgnoring(this.plugin, s.getUuid()) || (sender != null && s.getUuid().equals(sender.getUuid())); + return !this.plugin.getEventFactory().handleLogNotify(shouldCancel, entry, origin, s); }) .forEach(s -> Message.LOG.send(s, entry.getActorFriendlyString(), @@ -59,8 +60,8 @@ public class LogDispatcher { public void dispatch(ExtendedLogEntry entry, Sender sender) { // set the event to cancelled if the sender is import - if (!plugin.getEventFactory().handleLogPublish(sender.isImport(), entry)) { - plugin.getStorage().logAction(entry); + if (!this.plugin.getEventFactory().handleLogPublish(sender.isImport(), entry)) { + this.plugin.getStorage().logAction(entry); } // don't dispatch log entries sent by an import process @@ -68,21 +69,21 @@ public class LogDispatcher { return; } - Optional messagingService = plugin.getMessagingService(); + Optional messagingService = this.plugin.getMessagingService(); if (!sender.isImport() && messagingService.isPresent()) { messagingService.get().pushLog(entry); } - boolean shouldCancel = !plugin.getConfiguration().get(ConfigKeys.LOG_NOTIFY); - if (!plugin.getEventFactory().handleLogBroadcast(shouldCancel, entry, LogBroadcastEvent.Origin.LOCAL)) { + boolean shouldCancel = !this.plugin.getConfiguration().get(ConfigKeys.LOG_NOTIFY); + if (!this.plugin.getEventFactory().handleLogBroadcast(shouldCancel, entry, LogBroadcastEvent.Origin.LOCAL)) { broadcast(entry, LogBroadcastEvent.Origin.LOCAL, sender); } } public void dispatchFromApi(ExtendedLogEntry entry) { - if (!plugin.getEventFactory().handleLogPublish(false, entry)) { + if (!this.plugin.getEventFactory().handleLogPublish(false, entry)) { try { - plugin.getStorage().logAction(entry).get(); + this.plugin.getStorage().logAction(entry).get(); } catch (Exception e) { e.printStackTrace(); } @@ -92,17 +93,17 @@ public class LogDispatcher { } public void broadcastFromApi(ExtendedLogEntry entry) { - plugin.getMessagingService().ifPresent(extendedMessagingService -> extendedMessagingService.pushLog(entry)); + this.plugin.getMessagingService().ifPresent(extendedMessagingService -> extendedMessagingService.pushLog(entry)); - boolean shouldCancel = !plugin.getConfiguration().get(ConfigKeys.LOG_NOTIFY); - if (!plugin.getEventFactory().handleLogBroadcast(shouldCancel, entry, LogBroadcastEvent.Origin.LOCAL_API)) { + boolean shouldCancel = !this.plugin.getConfiguration().get(ConfigKeys.LOG_NOTIFY); + if (!this.plugin.getEventFactory().handleLogBroadcast(shouldCancel, entry, LogBroadcastEvent.Origin.LOCAL_API)) { broadcast(entry, LogBroadcastEvent.Origin.LOCAL_API, null); } } public void dispatchFromRemote(ExtendedLogEntry entry) { - boolean shouldCancel = !plugin.getConfiguration().get(ConfigKeys.BROADCAST_RECEIVED_LOG_ENTRIES) || !plugin.getConfiguration().get(ConfigKeys.LOG_NOTIFY); - if (!plugin.getEventFactory().handleLogBroadcast(shouldCancel, entry, LogBroadcastEvent.Origin.REMOTE)) { + boolean shouldCancel = !this.plugin.getConfiguration().get(ConfigKeys.BROADCAST_RECEIVED_LOG_ENTRIES) || !this.plugin.getConfiguration().get(ConfigKeys.LOG_NOTIFY); + if (!this.plugin.getEventFactory().handleLogBroadcast(shouldCancel, entry, LogBroadcastEvent.Origin.REMOTE)) { broadcast(entry, LogBroadcastEvent.Origin.LOCAL_API, null); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/ApiUtils.java b/common/src/main/java/me/lucko/luckperms/common/api/ApiUtils.java index f8fd681e0..849e891a8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/ApiUtils.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/ApiUtils.java @@ -25,14 +25,11 @@ package me.lucko.luckperms.common.api; -import lombok.experimental.UtilityClass; - import com.google.common.base.Preconditions; import me.lucko.luckperms.common.storage.DataConstraints; -@UtilityClass -public class ApiUtils { +public final class ApiUtils { public static String checkUsername(String s) { Preconditions.checkArgument( @@ -50,4 +47,6 @@ public class ApiUtils { return s.toLowerCase(); } + private ApiUtils() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/LuckPermsApiProvider.java b/common/src/main/java/me/lucko/luckperms/common/api/LuckPermsApiProvider.java index 5fdd915ec..77205cba9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/LuckPermsApiProvider.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/LuckPermsApiProvider.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.api; -import lombok.AccessLevel; -import lombok.Getter; - import me.lucko.luckperms.api.ActionLogger; import me.lucko.luckperms.api.LPConfiguration; import me.lucko.luckperms.api.LuckPermsApi; @@ -56,12 +53,13 @@ import java.util.Optional; import java.util.concurrent.CompletableFuture; import java.util.function.Function; +import javax.annotation.Nonnull; + /** * Implements the LuckPerms API using the plugin instance */ public class LuckPermsApiProvider implements LuckPermsApi { - @Getter(AccessLevel.NONE) private final LuckPermsPlugin plugin; private final PlatformInfo platformInfo; @@ -84,74 +82,86 @@ public class LuckPermsApiProvider implements LuckPermsApi { this.metaStackFactory = new ApiMetaStackFactory(plugin); } + @Nonnull @Override public PlatformInfo getPlatformInfo() { - return platformInfo; + return this.platformInfo; } + @Nonnull @Override public UserManager getUserManager() { - return userManager; + return this.userManager; } + @Nonnull @Override public GroupManager getGroupManager() { - return groupManager; + return this.groupManager; } + @Nonnull @Override public TrackManager getTrackManager() { - return trackManager; + return this.trackManager; } + @Nonnull @Override public CompletableFuture runUpdateTask() { - return plugin.getUpdateTaskBuffer().request(); + return this.plugin.getUpdateTaskBuffer().request(); } + @Nonnull @Override public EventBus getEventBus() { - return plugin.getEventFactory().getEventBus(); + return this.plugin.getEventFactory().getEventBus(); } + @Nonnull @Override public LPConfiguration getConfiguration() { - return plugin.getConfiguration().getDelegate(); + return this.plugin.getConfiguration().getDelegate(); } + @Nonnull @Override public Storage getStorage() { - return plugin.getStorage().getDelegate(); + return this.plugin.getStorage().getDelegate(); } + @Nonnull @Override public Optional getMessagingService() { - return plugin.getMessagingService().map(Function.identity()); + return this.plugin.getMessagingService().map(Function.identity()); } @Override public ActionLogger getActionLogger() { - return actionLogger; + return this.actionLogger; } + @Nonnull @Override public UuidCache getUuidCache() { - return plugin.getUuidCache().getDelegate(); + return this.plugin.getUuidCache().getDelegate(); } @Override public ContextManager getContextManager() { - return contextManager; + return this.contextManager; } + @Nonnull @Override public NodeFactory getNodeFactory() { return ApiNodeFactory.INSTANCE; } + @Nonnull @Override public MetaStackFactory getMetaStackFactory() { - return metaStackFactory; + return this.metaStackFactory; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiContextManager.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiContextManager.java index ad64706dc..39bf9a5ff 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiContextManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiContextManager.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.api.delegates.manager; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.context.ContextCalculator; @@ -37,73 +34,98 @@ import me.lucko.luckperms.api.context.StaticContextCalculator; import me.lucko.luckperms.common.api.delegates.model.ApiUser; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import java.util.Objects; import java.util.Optional; -@AllArgsConstructor +import javax.annotation.Nonnull; + @SuppressWarnings("unchecked") public class ApiContextManager implements ContextManager { private final LuckPermsPlugin plugin; private final me.lucko.luckperms.common.contexts.ContextManager handle; + public ApiContextManager(LuckPermsPlugin plugin, me.lucko.luckperms.common.contexts.ContextManager handle) { + this.plugin = plugin; + this.handle = handle; + } + private Object checkType(Object subject) { - if (!handle.getSubjectClass().isAssignableFrom(subject.getClass())) { - throw new IllegalStateException("Subject class " + subject.getClass() + " is not assignable from " + handle.getSubjectClass()); + if (!this.handle.getSubjectClass().isAssignableFrom(subject.getClass())) { + throw new IllegalStateException("Subject class " + subject.getClass() + " is not assignable from " + this.handle.getSubjectClass()); } return subject; } + @Nonnull @Override - public ImmutableContextSet getApplicableContext(@NonNull Object subject) { - return handle.getApplicableContext(checkType(subject)); + public ImmutableContextSet getApplicableContext(@Nonnull Object subject) { + Objects.requireNonNull(subject, "subject"); + return this.handle.getApplicableContext(checkType(subject)); } + @Nonnull @Override - public Contexts getApplicableContexts(@NonNull Object subject) { - return handle.getApplicableContexts(checkType(subject)); + public Contexts getApplicableContexts(@Nonnull Object subject) { + Objects.requireNonNull(subject, "subject"); + return this.handle.getApplicableContexts(checkType(subject)); } + @Nonnull @Override - public Optional lookupApplicableContext(@NonNull User user) { - return Optional.ofNullable(plugin.getContextForUser(ApiUser.cast(user))).map(c -> c.getContexts().makeImmutable()); + public Optional lookupApplicableContext(@Nonnull User user) { + Objects.requireNonNull(user, "user"); + return Optional.ofNullable(this.plugin.getContextForUser(ApiUser.cast(user))).map(c -> c.getContexts().makeImmutable()); } + @Nonnull @Override - public Optional lookupApplicableContexts(@NonNull User user) { - return Optional.ofNullable(plugin.getContextForUser(ApiUser.cast(user))); + public Optional lookupApplicableContexts(@Nonnull User user) { + Objects.requireNonNull(user, "user"); + return Optional.ofNullable(this.plugin.getContextForUser(ApiUser.cast(user))); } + @Nonnull @Override public ImmutableContextSet getStaticContext() { - return handle.getStaticContext(); + return this.handle.getStaticContext(); } + @Nonnull @Override public Contexts getStaticContexts() { - return handle.getStaticContexts(); + return this.handle.getStaticContexts(); + } + + @Nonnull + @Override + public Contexts formContexts(@Nonnull Object subject, @Nonnull ImmutableContextSet contextSet) { + Objects.requireNonNull(subject, "subject"); + Objects.requireNonNull(contextSet, "contextSet"); + return this.handle.formContexts(checkType(subject), contextSet); + } + + @Nonnull + @Override + public Contexts formContexts(@Nonnull ImmutableContextSet contextSet) { + Objects.requireNonNull(contextSet, "contextSet"); + return this.handle.formContexts(contextSet); } @Override - public Contexts formContexts(@NonNull Object subject, @NonNull ImmutableContextSet contextSet) { - return handle.formContexts(checkType(subject), contextSet); + public void registerCalculator(@Nonnull ContextCalculator calculator) { + Objects.requireNonNull(calculator, "calculator"); + this.handle.registerCalculator(calculator); } @Override - public Contexts formContexts(@NonNull ImmutableContextSet contextSet) { - return handle.formContexts(contextSet); + public void registerStaticCalculator(@Nonnull StaticContextCalculator calculator) { + Objects.requireNonNull(calculator, "calculator"); + this.handle.registerStaticCalculator(calculator); } @Override - public void registerCalculator(@NonNull ContextCalculator calculator) { - handle.registerCalculator(calculator); - } - - @Override - public void registerStaticCalculator(@NonNull StaticContextCalculator calculator) { - handle.registerStaticCalculator(calculator); - } - - @Override - public void invalidateCache(@NonNull Object subject) { - handle.invalidateCache(checkType(subject)); + public void invalidateCache(@Nonnull Object subject) { + Objects.requireNonNull(subject, "subject"); + this.handle.invalidateCache(checkType(subject)); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiGroupManager.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiGroupManager.java index 2c184f8d4..d2dab4784 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiGroupManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiGroupManager.java @@ -25,32 +25,38 @@ package me.lucko.luckperms.common.api.delegates.manager; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.manager.GroupManager; +import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ApiGroupManager implements GroupManager { private final me.lucko.luckperms.common.managers.GroupManager handle; + public ApiGroupManager(me.lucko.luckperms.common.managers.GroupManager handle) { + this.handle = handle; + } + @Override - public Group getGroup(@NonNull String name) { - me.lucko.luckperms.common.model.Group group = handle.getIfLoaded(name); + public Group getGroup(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + me.lucko.luckperms.common.model.Group group = this.handle.getIfLoaded(name); return group == null ? null : group.getDelegate(); } + @Nonnull @Override public Set getLoadedGroups() { - return handle.getAll().values().stream().map(me.lucko.luckperms.common.model.Group::getDelegate).collect(Collectors.toSet()); + return this.handle.getAll().values().stream().map(me.lucko.luckperms.common.model.Group::getDelegate).collect(Collectors.toSet()); } @Override - public boolean isLoaded(@NonNull String name) { - return handle.isLoaded(name); + public boolean isLoaded(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.isLoaded(name); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiTrackManager.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiTrackManager.java index bc7ddfcd7..fb27b4d98 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiTrackManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiTrackManager.java @@ -25,32 +25,38 @@ package me.lucko.luckperms.common.api.delegates.manager; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.manager.TrackManager; +import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ApiTrackManager implements TrackManager { private final me.lucko.luckperms.common.managers.TrackManager handle; + public ApiTrackManager(me.lucko.luckperms.common.managers.TrackManager handle) { + this.handle = handle; + } + @Override - public Track getTrack(@NonNull String name) { - me.lucko.luckperms.common.model.Track track = handle.getIfLoaded(name); + public Track getTrack(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + me.lucko.luckperms.common.model.Track track = this.handle.getIfLoaded(name); return track == null ? null : track.getDelegate(); } + @Nonnull @Override public Set getLoadedTracks() { - return handle.getAll().values().stream().map(me.lucko.luckperms.common.model.Track::getDelegate).collect(Collectors.toSet()); + return this.handle.getAll().values().stream().map(me.lucko.luckperms.common.model.Track::getDelegate).collect(Collectors.toSet()); } @Override - public boolean isLoaded(@NonNull String name) { - return handle.isLoaded(name); + public boolean isLoaded(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.isLoaded(name); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiUserManager.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiUserManager.java index 0faddd0f1..0ccf582d2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiUserManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/manager/ApiUserManager.java @@ -25,48 +25,57 @@ package me.lucko.luckperms.common.api.delegates.manager; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.manager.UserManager; import me.lucko.luckperms.common.api.delegates.model.ApiUser; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import me.lucko.luckperms.common.references.UserIdentifier; +import java.util.Objects; import java.util.Set; import java.util.UUID; import java.util.stream.Collectors; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ApiUserManager implements UserManager { private final LuckPermsPlugin plugin; private final me.lucko.luckperms.common.managers.UserManager handle; + public ApiUserManager(LuckPermsPlugin plugin, me.lucko.luckperms.common.managers.UserManager handle) { + this.plugin = plugin; + this.handle = handle; + } + @Override - public User getUser(@NonNull UUID uuid) { - me.lucko.luckperms.common.model.User user = handle.getIfLoaded(uuid); + public User getUser(@Nonnull UUID uuid) { + Objects.requireNonNull(uuid, "uuid"); + me.lucko.luckperms.common.model.User user = this.handle.getIfLoaded(uuid); return user == null ? null : user.getDelegate(); } @Override - public User getUser(@NonNull String name) { - me.lucko.luckperms.common.model.User user = handle.getByUsername(name); + public User getUser(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + me.lucko.luckperms.common.model.User user = this.handle.getByUsername(name); return user == null ? null : user.getDelegate(); } + @Nonnull @Override public Set getLoadedUsers() { - return handle.getAll().values().stream().map(me.lucko.luckperms.common.model.User::getDelegate).collect(Collectors.toSet()); + return this.handle.getAll().values().stream().map(me.lucko.luckperms.common.model.User::getDelegate).collect(Collectors.toSet()); } @Override - public boolean isLoaded(@NonNull UUID uuid) { - return handle.isLoaded(UserIdentifier.of(uuid, null)); + public boolean isLoaded(@Nonnull UUID uuid) { + Objects.requireNonNull(uuid, "uuid"); + return this.handle.isLoaded(UserIdentifier.of(uuid, null)); } @Override - public void cleanupUser(@NonNull User user) { - handle.scheduleUnload(plugin.getUuidCache().getExternalUUID(ApiUser.cast(user).getUuid())); + public void cleanupUser(@Nonnull User user) { + Objects.requireNonNull(user, "user"); + this.handle.scheduleUnload(this.plugin.getUuidCache().getExternalUUID(ApiUser.cast(user).getUuid())); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiActionLogger.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiActionLogger.java index 7e8d280aa..42fce03e2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiActionLogger.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiActionLogger.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.api.delegates.misc; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.ActionLogger; import me.lucko.luckperms.api.Log; import me.lucko.luckperms.api.LogEntry; @@ -36,32 +34,42 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.concurrent.CompletableFuture; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class ApiActionLogger implements ActionLogger { private final LuckPermsPlugin plugin; + public ApiActionLogger(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + @Nonnull @Override public LogEntry.Builder newEntryBuilder() { return ExtendedLogEntry.build(); } + @Nonnull @Override public CompletableFuture getLog() { - return plugin.getStorage().noBuffer().getLog().thenApply(log -> log == null ? null : new ApiLog(log)); + return this.plugin.getStorage().noBuffer().getLog().thenApply(log -> log == null ? null : new ApiLog(log)); } + @Nonnull @Override - public CompletableFuture submit(LogEntry entry) { - return CompletableFuture.runAsync(() -> plugin.getLogDispatcher().dispatchFromApi((ExtendedLogEntry) entry), plugin.getScheduler().async()); + public CompletableFuture submit(@Nonnull LogEntry entry) { + return CompletableFuture.runAsync(() -> this.plugin.getLogDispatcher().dispatchFromApi((ExtendedLogEntry) entry), this.plugin.getScheduler().async()); } + @Nonnull @Override - public CompletableFuture submitToStorage(LogEntry entry) { - return plugin.getStorage().noBuffer().logAction(entry); + public CompletableFuture submitToStorage(@Nonnull LogEntry entry) { + return this.plugin.getStorage().noBuffer().logAction(entry); } + @Nonnull @Override - public CompletableFuture broadcastAction(LogEntry entry) { - return CompletableFuture.runAsync(() -> plugin.getLogDispatcher().broadcastFromApi((ExtendedLogEntry) entry), plugin.getScheduler().async()); + public CompletableFuture broadcastAction(@Nonnull LogEntry entry) { + return CompletableFuture.runAsync(() -> this.plugin.getLogDispatcher().broadcastFromApi((ExtendedLogEntry) entry), this.plugin.getScheduler().async()); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiConfiguration.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiConfiguration.java index 3cf800fc3..8e0f38740 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiConfiguration.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiConfiguration.java @@ -33,6 +33,8 @@ import me.lucko.luckperms.common.utils.ImmutableCollectors; import java.util.Map; +import javax.annotation.Nonnull; + public class ApiConfiguration implements LPConfiguration { private final LuckPermsConfiguration handle; private final Unsafe unsafe; @@ -42,61 +44,66 @@ public class ApiConfiguration implements LPConfiguration { this.unsafe = new UnsafeImpl(); } + @Nonnull @Override public String getServer() { - return handle.get(ConfigKeys.SERVER); + return this.handle.get(ConfigKeys.SERVER); } @Override public boolean getIncludeGlobalPerms() { - return handle.get(ConfigKeys.INCLUDING_GLOBAL_PERMS); + return this.handle.get(ConfigKeys.INCLUDING_GLOBAL_PERMS); } @Override public boolean getIncludeGlobalWorldPerms() { - return handle.get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS); + return this.handle.get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS); } @Override public boolean getApplyGlobalGroups() { - return handle.get(ConfigKeys.APPLYING_GLOBAL_GROUPS); + return this.handle.get(ConfigKeys.APPLYING_GLOBAL_GROUPS); } @Override public boolean getApplyGlobalWorldGroups() { - return handle.get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS); + return this.handle.get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS); } + @Nonnull @Override public String getStorageMethod() { - return handle.get(ConfigKeys.STORAGE_METHOD); + return this.handle.get(ConfigKeys.STORAGE_METHOD); } @Override public boolean getSplitStorage() { - return handle.get(ConfigKeys.SPLIT_STORAGE); + return this.handle.get(ConfigKeys.SPLIT_STORAGE); } + @Nonnull @Override public Map getSplitStorageOptions() { - return handle.get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream() + return this.handle.get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream() .collect(ImmutableCollectors.toMap(e -> e.getKey().name().toLowerCase(), Map.Entry::getValue)); } + @Nonnull @Override public Unsafe unsafe() { - return unsafe; + return this.unsafe; } private final class UnsafeImpl implements Unsafe { + @Nonnull @Override public Object getObject(String key) { ConfigKey configKey = ConfigKeys.getAllKeys().get(key.toUpperCase()); if (configKey == null) { throw new IllegalArgumentException("Unknown key: " + key); } - return handle.get(configKey); + return ApiConfiguration.this.handle.get(configKey); } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiMetaStackFactory.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiMetaStackFactory.java index 007df952c..07e9266e2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiMetaStackFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiMetaStackFactory.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.api.delegates.misc; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.metastacking.MetaStackDefinition; @@ -38,27 +35,38 @@ import me.lucko.luckperms.common.metastacking.StandardStackElements; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.List; +import java.util.Objects; import java.util.Optional; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ApiMetaStackFactory implements MetaStackFactory { public final LuckPermsPlugin plugin; - @Override - public Optional fromString(@NonNull String definition) { - return StandardStackElements.parseFromString(plugin, definition); + public ApiMetaStackFactory(LuckPermsPlugin plugin) { + this.plugin = plugin; } + @Nonnull @Override - public List fromStrings(@NonNull List definitions) { + public Optional fromString(@Nonnull String definition) { + Objects.requireNonNull(definition, "definition"); + return StandardStackElements.parseFromString(this.plugin, definition); + } + + @Nonnull + @Override + public List fromStrings(@Nonnull List definitions) { + Objects.requireNonNull(definitions, "definitions"); if (definitions.isEmpty()) { return ImmutableList.of(); } - return StandardStackElements.parseList(plugin, definitions); + return StandardStackElements.parseList(this.plugin, definitions); } + @Nonnull @Override - public MetaStackDefinition createDefinition(List elements, String startSpacer, String middleSpacer, String endSpacer) { + public MetaStackDefinition createDefinition(@Nonnull List elements, @Nonnull String startSpacer, @Nonnull String middleSpacer, @Nonnull String endSpacer) { return new SimpleMetaStackDefinition(elements, startSpacer, middleSpacer, endSpacer); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiNodeFactory.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiNodeFactory.java index 81c7347f3..0614d327d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiNodeFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiNodeFactory.java @@ -25,14 +25,16 @@ package me.lucko.luckperms.common.api.delegates.misc; -import lombok.NonNull; - import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.api.delegates.model.ApiGroup; import me.lucko.luckperms.common.node.NodeFactory; +import java.util.Objects; + +import javax.annotation.Nonnull; + public final class ApiNodeFactory implements me.lucko.luckperms.api.NodeFactory { public static final ApiNodeFactory INSTANCE = new ApiNodeFactory(); @@ -40,43 +42,61 @@ public final class ApiNodeFactory implements me.lucko.luckperms.api.NodeFactory } + @Nonnull @Override - public Node.Builder newBuilder(@NonNull String permission) { + public Node.Builder newBuilder(@Nonnull String permission) { + Objects.requireNonNull(permission, "permission"); return NodeFactory.builder(permission); } + @Nonnull @Override - public Node.Builder newBuilderFromExisting(@NonNull Node other) { + public Node.Builder newBuilderFromExisting(@Nonnull Node other) { + Objects.requireNonNull(other, "other"); return NodeFactory.builder(other); } + @Nonnull @Override - public Node.Builder makeGroupNode(Group group) { + public Node.Builder makeGroupNode(@Nonnull Group group) { + Objects.requireNonNull(group, "group"); return NodeFactory.buildGroupNode(ApiGroup.cast(group)); } + @Nonnull @Override - public Node.Builder makeGroupNode(String groupName) { + public Node.Builder makeGroupNode(@Nonnull String groupName) { + Objects.requireNonNull(groupName, "groupName"); return NodeFactory.buildGroupNode(groupName); } + @Nonnull @Override - public Node.Builder makeMetaNode(@NonNull String key, @NonNull String value) { + public Node.Builder makeMetaNode(@Nonnull String key, @Nonnull String value) { + Objects.requireNonNull(key, "key"); + Objects.requireNonNull(value, "value"); return NodeFactory.buildMetaNode(key, value); } + @Nonnull @Override - public Node.Builder makeChatMetaNode(@NonNull ChatMetaType type, int priority, @NonNull String value) { + public Node.Builder makeChatMetaNode(@Nonnull ChatMetaType type, int priority, @Nonnull String value) { + Objects.requireNonNull(type, "type"); + Objects.requireNonNull(value, "value"); return NodeFactory.buildChatMetaNode(type, priority, value); } + @Nonnull @Override - public Node.Builder makePrefixNode(int priority, @NonNull String prefix) { + public Node.Builder makePrefixNode(int priority, @Nonnull String prefix) { + Objects.requireNonNull(prefix, "prefix"); return NodeFactory.buildPrefixNode(priority, prefix); } + @Nonnull @Override - public Node.Builder makeSuffixNode(int priority, @NonNull String suffix) { + public Node.Builder makeSuffixNode(int priority, @Nonnull String suffix) { + Objects.requireNonNull(suffix, "suffix"); return NodeFactory.buildSuffixNode(priority, suffix); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiPlatformInfo.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiPlatformInfo.java index d407f5a3b..a0a66ca3f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiPlatformInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiPlatformInfo.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.api.delegates.misc; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.platform.PlatformInfo; import me.lucko.luckperms.api.platform.PlatformType; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; @@ -35,13 +33,19 @@ import java.util.Collections; import java.util.Set; import java.util.UUID; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class ApiPlatformInfo implements PlatformInfo { private final LuckPermsPlugin plugin; + public ApiPlatformInfo(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + @Nonnull @Override public String getVersion() { - return plugin.getVersion(); + return this.plugin.getVersion(); } @Override @@ -49,18 +53,20 @@ public class ApiPlatformInfo implements PlatformInfo { return 4.0; } + @Nonnull @Override public PlatformType getType() { - return plugin.getServerType(); + return this.plugin.getServerType(); } + @Nonnull @Override public Set getUniqueConnections() { - return Collections.unmodifiableSet(plugin.getUniqueConnections()); + return Collections.unmodifiableSet(this.plugin.getUniqueConnections()); } @Override public long getStartTime() { - return plugin.getStartTime(); + return this.plugin.getStartTime(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiUuidCache.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiUuidCache.java index 4dc0c039a..42dff1c03 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiUuidCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/misc/ApiUuidCache.java @@ -25,24 +25,31 @@ package me.lucko.luckperms.common.api.delegates.misc; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.UuidCache; +import java.util.Objects; import java.util.UUID; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ApiUuidCache implements UuidCache { private final me.lucko.luckperms.common.utils.UuidCache handle; - @Override - public UUID getUUID(@NonNull UUID external) { - return handle.getUUID(external); + public ApiUuidCache(me.lucko.luckperms.common.utils.UuidCache handle) { + this.handle = handle; } + @Nonnull @Override - public UUID getExternalUUID(@NonNull UUID internal) { - return handle.getExternalUUID(internal); + public UUID getUUID(@Nonnull UUID external) { + Objects.requireNonNull(external, "external"); + return this.handle.getUUID(external); + } + + @Nonnull + @Override + public UUID getExternalUUID(@Nonnull UUID internal) { + Objects.requireNonNull(internal, "internal"); + return this.handle.getExternalUUID(internal); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiGroup.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiGroup.java index 5237813d5..fb14953e5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiGroup.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiGroup.java @@ -25,55 +25,63 @@ package me.lucko.luckperms.common.api.delegates.model; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.NonNull; - import com.google.common.base.Preconditions; import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.caching.GroupData; +import java.util.Objects; import java.util.OptionalInt; +import javax.annotation.Nonnull; + public final class ApiGroup extends ApiPermissionHolder implements Group { - public static me.lucko.luckperms.common.model.Group cast(Group g) { - Preconditions.checkState(g instanceof ApiGroup, "Illegal instance " + g.getClass() + " cannot be handled by this implementation."); - return ((ApiGroup) g).getHandle(); + public static me.lucko.luckperms.common.model.Group cast(Group group) { + Objects.requireNonNull(group, "group"); + Preconditions.checkState(group instanceof ApiGroup, "Illegal instance " + group.getClass() + " cannot be handled by this implementation."); + return ((ApiGroup) group).getHandle(); } - @Getter(AccessLevel.PACKAGE) private final me.lucko.luckperms.common.model.Group handle; - public ApiGroup(@NonNull me.lucko.luckperms.common.model.Group handle) { + public ApiGroup(me.lucko.luckperms.common.model.Group handle) { super(handle); this.handle = handle; } @Override - public String getName() { - return handle.getName(); + me.lucko.luckperms.common.model.Group getHandle() { + return this.handle; } + @Nonnull + @Override + public String getName() { + return this.handle.getName(); + } + + @Nonnull @Override public OptionalInt getWeight() { - return handle.getWeight(); + return this.handle.getWeight(); + } + + @Nonnull + @Override + public GroupData getCachedData() { + return this.handle.getCachedData(); } @Override - public GroupData getCachedData() { - return handle.getCachedData(); - } - public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof ApiGroup)) return false; - - ApiGroup other = (ApiGroup) o; - return handle.equals(other.handle); + ApiGroup that = (ApiGroup) o; + return this.handle.equals(that.handle); } + @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiLog.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiLog.java index 8091070ac..99ceeec41 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiLog.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiLog.java @@ -25,116 +25,147 @@ package me.lucko.luckperms.common.api.delegates.model; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.Log; import me.lucko.luckperms.api.LogEntry; +import java.util.Objects; import java.util.SortedMap; import java.util.SortedSet; import java.util.UUID; +import javax.annotation.Nonnull; + import static me.lucko.luckperms.common.api.ApiUtils.checkName; @SuppressWarnings("unchecked") -@AllArgsConstructor public class ApiLog implements Log { private static final int ENTRIES_PER_PAGE = 5; private final me.lucko.luckperms.common.actionlog.Log handle; + public ApiLog(me.lucko.luckperms.common.actionlog.Log handle) { + this.handle = handle; + } + + @Nonnull @Override public SortedSet getContent() { - return (SortedSet) handle.getContent(); + return (SortedSet) this.handle.getContent(); } + @Nonnull @Override public SortedSet getRecent() { - return (SortedSet) handle.getRecent(); + return (SortedSet) this.handle.getRecent(); } + @Nonnull @Override public SortedMap getRecent(int pageNo) { - return (SortedMap) handle.getRecent(pageNo, ENTRIES_PER_PAGE); + return (SortedMap) this.handle.getRecent(pageNo, ENTRIES_PER_PAGE); } @Override public int getRecentMaxPages() { - return handle.getRecentMaxPages(ENTRIES_PER_PAGE); + return this.handle.getRecentMaxPages(ENTRIES_PER_PAGE); + } + + @Nonnull + @Override + public SortedSet getRecent(@Nonnull UUID actor) { + Objects.requireNonNull(actor, "actor"); + return (SortedSet) this.handle.getRecent(actor); + } + + @Nonnull + @Override + public SortedMap getRecent(int pageNo, @Nonnull UUID actor) { + Objects.requireNonNull(actor, "actor"); + return (SortedMap) this.handle.getRecent(pageNo, actor, ENTRIES_PER_PAGE); } @Override - public SortedSet getRecent(@NonNull UUID actor) { - return (SortedSet) handle.getRecent(actor); + public int getRecentMaxPages(@Nonnull UUID actor) { + Objects.requireNonNull(actor, "actor"); + return this.handle.getRecentMaxPages(actor, ENTRIES_PER_PAGE); + } + + @Nonnull + @Override + public SortedSet getUserHistory(@Nonnull UUID uuid) { + Objects.requireNonNull(uuid, "uuid"); + return (SortedSet) this.handle.getUserHistory(uuid); + } + + @Nonnull + @Override + public SortedMap getUserHistory(int pageNo, @Nonnull UUID uuid) { + Objects.requireNonNull(uuid, "uuid"); + return (SortedMap) this.handle.getUserHistory(pageNo, uuid, ENTRIES_PER_PAGE); } @Override - public SortedMap getRecent(int pageNo, @NonNull UUID actor) { - return (SortedMap) handle.getRecent(pageNo, actor, ENTRIES_PER_PAGE); + public int getUserHistoryMaxPages(@Nonnull UUID uuid) { + Objects.requireNonNull(uuid, "uuid"); + return this.handle.getUserHistoryMaxPages(uuid, ENTRIES_PER_PAGE); + } + + @Nonnull + @Override + public SortedSet getGroupHistory(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return (SortedSet) this.handle.getGroupHistory(checkName(name)); + } + + @Nonnull + @Override + public SortedMap getGroupHistory(int pageNo, @Nonnull String name) { + Objects.requireNonNull(name, "name"); + return (SortedMap) this.handle.getGroupHistory(pageNo, checkName(name), ENTRIES_PER_PAGE); } @Override - public int getRecentMaxPages(@NonNull UUID actor) { - return handle.getRecentMaxPages(actor, ENTRIES_PER_PAGE); + public int getGroupHistoryMaxPages(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.getGroupHistoryMaxPages(checkName(name), ENTRIES_PER_PAGE); + } + + @Nonnull + @Override + public SortedSet getTrackHistory(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return (SortedSet) this.handle.getTrackHistory(checkName(name)); + } + + @Nonnull + @Override + public SortedMap getTrackHistory(int pageNo, @Nonnull String name) { + Objects.requireNonNull(name, "name"); + return (SortedMap) this.handle.getTrackHistory(pageNo, checkName(name), ENTRIES_PER_PAGE); } @Override - public SortedSet getUserHistory(@NonNull UUID uuid) { - return (SortedSet) handle.getUserHistory(uuid); + public int getTrackHistoryMaxPages(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.getTrackHistoryMaxPages(checkName(name), ENTRIES_PER_PAGE); + } + + @Nonnull + @Override + public SortedSet getSearch(@Nonnull String query) { + Objects.requireNonNull(query, "query"); + return (SortedSet) this.handle.getSearch(query); + } + + @Nonnull + @Override + public SortedMap getSearch(int pageNo, @Nonnull String query) { + Objects.requireNonNull(query, "query"); + return (SortedMap) this.handle.getSearch(pageNo, query, ENTRIES_PER_PAGE); } @Override - public SortedMap getUserHistory(int pageNo, @NonNull UUID uuid) { - return (SortedMap) handle.getUserHistory(pageNo, uuid, ENTRIES_PER_PAGE); - } - - @Override - public int getUserHistoryMaxPages(@NonNull UUID uuid) { - return handle.getUserHistoryMaxPages(uuid, ENTRIES_PER_PAGE); - } - - @Override - public SortedSet getGroupHistory(@NonNull String name) { - return (SortedSet) handle.getGroupHistory(checkName(name)); - } - - @Override - public SortedMap getGroupHistory(int pageNo, @NonNull String name) { - return (SortedMap) handle.getGroupHistory(pageNo, checkName(name), ENTRIES_PER_PAGE); - } - - @Override - public int getGroupHistoryMaxPages(@NonNull String name) { - return handle.getGroupHistoryMaxPages(checkName(name), ENTRIES_PER_PAGE); - } - - @Override - public SortedSet getTrackHistory(@NonNull String name) { - return (SortedSet) handle.getTrackHistory(checkName(name)); - } - - @Override - public SortedMap getTrackHistory(int pageNo, @NonNull String name) { - return (SortedMap) handle.getTrackHistory(pageNo, checkName(name), ENTRIES_PER_PAGE); - } - - @Override - public int getTrackHistoryMaxPages(@NonNull String name) { - return handle.getTrackHistoryMaxPages(checkName(name), ENTRIES_PER_PAGE); - } - - @Override - public SortedSet getSearch(@NonNull String query) { - return (SortedSet) handle.getSearch(query); - } - - @Override - public SortedMap getSearch(int pageNo, @NonNull String query) { - return (SortedMap) handle.getSearch(pageNo, query, ENTRIES_PER_PAGE); - } - - @Override - public int getSearchMaxPages(@NonNull String query) { - return handle.getSearchMaxPages(query, ENTRIES_PER_PAGE); + public int getSearchMaxPages(@Nonnull String query) { + Objects.requireNonNull(query, "query"); + return this.handle.getSearchMaxPages(query, ENTRIES_PER_PAGE); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiPermissionHolder.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiPermissionHolder.java index 5fd800ad6..7a0407224 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiPermissionHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiPermissionHolder.java @@ -25,9 +25,8 @@ package me.lucko.luckperms.common.api.delegates.model; -import lombok.AllArgsConstructor; -import lombok.NonNull; - +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.ImmutableSetMultimap; import com.google.common.collect.ImmutableSortedSet; @@ -44,212 +43,263 @@ import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.model.User; import me.lucko.luckperms.common.node.MetaType; +import me.lucko.luckperms.common.utils.ImmutableCollectors; -import java.util.HashMap; -import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.SortedSet; -import java.util.TreeSet; import java.util.concurrent.CompletableFuture; import java.util.function.Predicate; -import java.util.stream.Collectors; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ApiPermissionHolder implements PermissionHolder { private final me.lucko.luckperms.common.model.PermissionHolder handle; - @Override - public String getObjectName() { - return handle.getObjectName(); + public ApiPermissionHolder(me.lucko.luckperms.common.model.PermissionHolder handle) { + this.handle = Objects.requireNonNull(handle, "handle"); } + me.lucko.luckperms.common.model.PermissionHolder getHandle() { + return this.handle; + } + + @Nonnull + @Override + public String getObjectName() { + return this.handle.getObjectName(); + } + + @Nonnull @Override public String getFriendlyName() { - if (handle.getType().isGroup()) { + if (this.handle.getType().isGroup()) { Group group = (Group) this.handle; return group.getDisplayName().orElse(group.getName()); } - return handle.getFriendlyName(); + return this.handle.getFriendlyName(); } + @Nonnull @Override public CachedData getCachedData() { - return handle.getCachedData(); + return this.handle.getCachedData(); } + @Nonnull @Override public CompletableFuture refreshCachedData() { - return handle.getRefreshBuffer().request(); + return this.handle.getRefreshBuffer().request(); } + @Nonnull @Override public ImmutableSetMultimap getNodes() { - return handle.getEnduringNodes(); + return this.handle.getEnduringNodes(); } + @Nonnull @Override public ImmutableSetMultimap getTransientNodes() { - return handle.getTransientNodes(); + return this.handle.getTransientNodes(); } + @Nonnull @Override public List getOwnNodes() { - return handle.getOwnNodes(); + return ImmutableList.copyOf(this.handle.getOwnNodes()); } + @Nonnull @Override public SortedSet getPermissions() { - return ImmutableSortedSet.copyOfSorted(handle.getOwnNodesSorted()); + return ImmutableSortedSet.copyOfSorted(this.handle.getOwnNodesSorted()); } + @Nonnull @Override public Set getEnduringPermissions() { - return ImmutableSet.copyOf(handle.getEnduringNodes().values()); + return ImmutableSet.copyOf(this.handle.getEnduringNodes().values()); } + @Nonnull @Override public Set getTransientPermissions() { - return ImmutableSet.copyOf(handle.getTransientNodes().values()); + return ImmutableSet.copyOf(this.handle.getTransientNodes().values()); } + @Nonnull @Override - public SortedSet getAllNodes(@NonNull Contexts contexts) { - return new TreeSet<>(handle.resolveInheritancesAlmostEqual(contexts)); + public SortedSet getAllNodes(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + return ImmutableSortedSet.copyOfSorted(this.handle.resolveInheritancesAlmostEqual(contexts)); } + @Nonnull @Override public SortedSet getAllNodes() { - return new TreeSet<>(handle.resolveInheritancesAlmostEqual()); + return ImmutableSortedSet.copyOfSorted(this.handle.resolveInheritancesAlmostEqual()); + } + + @Nonnull + @Override + public Set getAllNodesFiltered(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + return ImmutableSet.copyOf(this.handle.getAllNodes(contexts)); + } + + @Nonnull + @Override + public Map exportNodes(@Nonnull Contexts contexts, boolean lowerCase) { + Objects.requireNonNull(contexts, "contexts"); + return ImmutableMap.copyOf(this.handle.exportNodesAndShorthand(contexts, lowerCase)); + } + + @Nonnull + @Override + public Tristate hasPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.hasPermission(node, false); + } + + @Nonnull + @Override + public Tristate hasTransientPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.hasPermission(node, true); + } + + @Nonnull + @Override + public Tristate inheritsPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.inheritsPermission(node); } @Override - public Set getAllNodesFiltered(@NonNull Contexts contexts) { - return new HashSet<>(handle.getAllNodes(contexts)); + public boolean inheritsGroup(@Nonnull me.lucko.luckperms.api.Group group) { + Objects.requireNonNull(group, "group"); + return this.handle.inheritsGroup(ApiGroup.cast(group)); } @Override - public Map exportNodes(Contexts contexts, boolean lowerCase) { - return new HashMap<>(handle.exportNodesAndShorthand(contexts, lowerCase)); + public boolean inheritsGroup(@Nonnull me.lucko.luckperms.api.Group group, @Nonnull ContextSet contextSet) { + Objects.requireNonNull(group, "group"); + Objects.requireNonNull(contextSet, "contextSet"); + return this.handle.inheritsGroup(ApiGroup.cast(group), contextSet); + } + + @Nonnull + @Override + public DataMutateResult setPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.setPermission(node); + } + + @Nonnull + @Override + public DataMutateResult setTransientPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.setTransientPermission(node); + } + + @Nonnull + @Override + public DataMutateResult unsetPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.unsetPermission(node); + } + + @Nonnull + @Override + public DataMutateResult unsetTransientPermission(@Nonnull Node node) { + Objects.requireNonNull(node, "node"); + return this.handle.unsetTransientPermission(node); } @Override - public Tristate hasPermission(@NonNull Node node) { - return handle.hasPermission(node, false); - } - - @Override - public Tristate hasTransientPermission(@NonNull Node node) { - return handle.hasPermission(node, true); - } - - @Override - public Tristate inheritsPermission(@NonNull Node node) { - return handle.inheritsPermission(node); - } - - @Override - public boolean inheritsGroup(@NonNull me.lucko.luckperms.api.Group group) { - return handle.inheritsGroup(ApiGroup.cast(group)); - } - - @Override - public boolean inheritsGroup(@NonNull me.lucko.luckperms.api.Group group, @NonNull ContextSet contextSet) { - return handle.inheritsGroup(ApiGroup.cast(group), contextSet); - } - - @Override - public DataMutateResult setPermission(@NonNull Node node) { - return handle.setPermission(node); - } - - @Override - public DataMutateResult setTransientPermission(@NonNull Node node) { - return handle.setTransientPermission(node); - } - - @Override - public DataMutateResult unsetPermission(@NonNull Node node) { - return handle.unsetPermission(node); - } - - @Override - public DataMutateResult unsetTransientPermission(@NonNull Node node) { - return handle.unsetTransientPermission(node); - } - - @Override - public void clearMatching(@NonNull Predicate test) { - handle.removeIf(test); - if (handle.getType().isUser()) { - handle.getPlugin().getUserManager().giveDefaultIfNeeded((User) handle, false); + public void clearMatching(@Nonnull Predicate test) { + Objects.requireNonNull(test, "test"); + this.handle.removeIf(test); + if (this.handle.getType().isUser()) { + this.handle.getPlugin().getUserManager().giveDefaultIfNeeded((User) this.handle, false); } } @Override - public void clearMatchingTransient(@NonNull Predicate test) { - handle.removeIfTransient(test); + public void clearMatchingTransient(@Nonnull Predicate test) { + Objects.requireNonNull(test, "test"); + this.handle.removeIfTransient(test); } @Override public void clearNodes() { - handle.clearNodes(); + this.handle.clearNodes(); } @Override - public void clearNodes(@NonNull ContextSet contextSet) { - handle.clearNodes(contextSet); + public void clearNodes(@Nonnull ContextSet contextSet) { + Objects.requireNonNull(contextSet, "contextSet"); + this.handle.clearNodes(contextSet); } @Override public void clearParents() { - handle.clearParents(true); + this.handle.clearParents(true); } @Override - public void clearParents(@NonNull ContextSet contextSet) { - handle.clearParents(contextSet, true); + public void clearParents(@Nonnull ContextSet contextSet) { + Objects.requireNonNull(contextSet, "contextSet"); + this.handle.clearParents(contextSet, true); } @Override public void clearMeta() { - handle.clearMeta(MetaType.ANY); + this.handle.clearMeta(MetaType.ANY); } @Override - public void clearMeta(@NonNull ContextSet contextSet) { - handle.clearMeta(MetaType.ANY, contextSet); + public void clearMeta(@Nonnull ContextSet contextSet) { + Objects.requireNonNull(contextSet, "contextSet"); + this.handle.clearMeta(MetaType.ANY, contextSet); } @Override public void clearTransientNodes() { - handle.clearTransientNodes(); + this.handle.clearTransientNodes(); } + @Nonnull @Override public List resolveInheritances(Contexts contexts) { - return handle.resolveInheritances(contexts); + Objects.requireNonNull(contexts, "contexts"); + return ImmutableList.copyOf(this.handle.resolveInheritances(contexts)); } + @Nonnull @Override public List resolveInheritances() { - return handle.resolveInheritances(); + return ImmutableList.copyOf(this.handle.resolveInheritances()); } + @Nonnull @Override public Set getPermanentPermissionNodes() { - return handle.getOwnNodes().stream().filter(Node::isPermanent).collect(Collectors.toSet()); + return this.handle.getOwnNodes().stream().filter(Node::isPermanent).collect(ImmutableCollectors.toSet()); } + @Nonnull @Override public Set getTemporaryPermissionNodes() { - return handle.getOwnNodes().stream().filter(Node::isPrefix).collect(Collectors.toSet()); + return this.handle.getOwnNodes().stream().filter(Node::isPrefix).collect(ImmutableCollectors.toSet()); } @Override public void auditTemporaryPermissions() { - handle.auditTemporaryPermissions(); + this.handle.auditTemporaryPermissions(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiStorage.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiStorage.java index c6414e3d1..affee9eb0 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiStorage.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiStorage.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.api.delegates.model; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.HeldPermission; import me.lucko.luckperms.api.Log; @@ -48,17 +45,24 @@ import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; +import javax.annotation.Nonnull; + import static me.lucko.luckperms.common.api.ApiUtils.checkName; import static me.lucko.luckperms.common.api.ApiUtils.checkUsername; -@AllArgsConstructor public class ApiStorage implements Storage { private final LuckPermsPlugin plugin; private final me.lucko.luckperms.common.storage.Storage handle; + + public ApiStorage(LuckPermsPlugin plugin, me.lucko.luckperms.common.storage.Storage handle) { + this.plugin = plugin; + this.handle = handle; + } + @Nonnull @Override public String getName() { - return handle.getName(); + return this.handle.getName(); } @Override @@ -66,116 +70,155 @@ public class ApiStorage implements Storage { return true; } + @Nonnull @Override public Executor getSyncExecutor() { - return plugin.getScheduler().sync(); + return this.plugin.getScheduler().sync(); } + @Nonnull @Override public Executor getAsyncExecutor() { - return plugin.getScheduler().async(); + return this.plugin.getScheduler().async(); } + @Nonnull @Override - public CompletableFuture logAction(@NonNull LogEntry entry) { - return handle.noBuffer().logAction(entry).thenApply(x -> true); + public CompletableFuture logAction(@Nonnull LogEntry entry) { + Objects.requireNonNull(entry, "entry"); + return this.handle.noBuffer().logAction(entry).thenApply(x -> true); } + @Nonnull @Override public CompletableFuture getLog() { - return handle.noBuffer().getLog().thenApply(log -> log == null ? null : new ApiLog(log)); + return this.handle.noBuffer().getLog().thenApply(log -> log == null ? null : new ApiLog(log)); } + @Nonnull @Override - public CompletableFuture loadUser(@NonNull UUID uuid, String username) { - return handle.noBuffer().loadUser(uuid, username == null ? null : checkUsername(username)).thenApply(Objects::nonNull); + public CompletableFuture loadUser(@Nonnull UUID uuid, String username) { + Objects.requireNonNull(uuid, "uuid"); + return this.handle.noBuffer().loadUser(uuid, username == null ? null : checkUsername(username)).thenApply(Objects::nonNull); } + @Nonnull @Override - public CompletableFuture saveUser(@NonNull User user) { - return handle.noBuffer().saveUser(ApiUser.cast(user)).thenApply(x -> true); + public CompletableFuture saveUser(@Nonnull User user) { + Objects.requireNonNull(user, "user"); + return this.handle.noBuffer().saveUser(ApiUser.cast(user)).thenApply(x -> true); } + @Nonnull @Override public CompletableFuture> getUniqueUsers() { - return handle.noBuffer().getUniqueUsers(); + return this.handle.noBuffer().getUniqueUsers(); } + @Nonnull @Override - public CompletableFuture>> getUsersWithPermission(@NonNull String permission) { - return handle.noBuffer().getUsersWithPermission(permission); + public CompletableFuture>> getUsersWithPermission(@Nonnull String permission) { + Objects.requireNonNull(permission, "permission"); + return this.handle.noBuffer().getUsersWithPermission(permission); } + @Nonnull @Override - public CompletableFuture createAndLoadGroup(@NonNull String name) { - return handle.noBuffer().createAndLoadGroup(checkName(name), CreationCause.API).thenApply(Objects::nonNull); + public CompletableFuture createAndLoadGroup(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.noBuffer().createAndLoadGroup(checkName(name), CreationCause.API).thenApply(Objects::nonNull); } + @Nonnull @Override - public CompletableFuture loadGroup(@NonNull String name) { - return handle.noBuffer().loadGroup(checkName(name)).thenApply(Optional::isPresent); + public CompletableFuture loadGroup(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.noBuffer().loadGroup(checkName(name)).thenApply(Optional::isPresent); } + @Nonnull @Override public CompletableFuture loadAllGroups() { - return handle.noBuffer().loadAllGroups().thenApply(x -> true); + return this.handle.noBuffer().loadAllGroups().thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture saveGroup(@NonNull Group group) { - return handle.noBuffer().saveGroup(ApiGroup.cast(group)).thenApply(x -> true); + public CompletableFuture saveGroup(@Nonnull Group group) { + Objects.requireNonNull(group, "group"); + return this.handle.noBuffer().saveGroup(ApiGroup.cast(group)).thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture deleteGroup(@NonNull Group group) { - if (group.getName().equalsIgnoreCase(plugin.getConfiguration().get(ConfigKeys.DEFAULT_GROUP_NAME))) { + public CompletableFuture deleteGroup(@Nonnull Group group) { + Objects.requireNonNull(group, "group"); + if (group.getName().equalsIgnoreCase(this.plugin.getConfiguration().get(ConfigKeys.DEFAULT_GROUP_NAME))) { throw new IllegalArgumentException("Cannot delete the default group."); } - return handle.noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API).thenApply(x -> true); + return this.handle.noBuffer().deleteGroup(ApiGroup.cast(group), DeletionCause.API).thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture>> getGroupsWithPermission(@NonNull String permission) { - return handle.noBuffer().getGroupsWithPermission(permission); + public CompletableFuture>> getGroupsWithPermission(@Nonnull String permission) { + Objects.requireNonNull(permission, "permission"); + return this.handle.noBuffer().getGroupsWithPermission(permission); } + @Nonnull @Override - public CompletableFuture createAndLoadTrack(@NonNull String name) { - return handle.noBuffer().createAndLoadTrack(checkName(name), CreationCause.API).thenApply(Objects::nonNull); + public CompletableFuture createAndLoadTrack(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.noBuffer().createAndLoadTrack(checkName(name), CreationCause.API).thenApply(Objects::nonNull); } + @Nonnull @Override - public CompletableFuture loadTrack(@NonNull String name) { - return handle.noBuffer().loadTrack(checkName(name)).thenApply(Optional::isPresent); + public CompletableFuture loadTrack(@Nonnull String name) { + Objects.requireNonNull(name, "name"); + return this.handle.noBuffer().loadTrack(checkName(name)).thenApply(Optional::isPresent); } + @Nonnull @Override public CompletableFuture loadAllTracks() { - return handle.noBuffer().loadAllTracks().thenApply(x -> true); + return this.handle.noBuffer().loadAllTracks().thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture saveTrack(@NonNull Track track) { - return handle.noBuffer().saveTrack(ApiTrack.cast(track)).thenApply(x -> true); + public CompletableFuture saveTrack(@Nonnull Track track) { + Objects.requireNonNull(track, "track"); + return this.handle.noBuffer().saveTrack(ApiTrack.cast(track)).thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture deleteTrack(@NonNull Track track) { - return handle.noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API).thenApply(x -> true); + public CompletableFuture deleteTrack(@Nonnull Track track) { + Objects.requireNonNull(track, "track"); + return this.handle.noBuffer().deleteTrack(ApiTrack.cast(track), DeletionCause.API).thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture saveUUIDData(@NonNull String username, @NonNull UUID uuid) { - return handle.noBuffer().saveUUIDData(uuid, checkUsername(username)).thenApply(x -> true); + public CompletableFuture saveUUIDData(@Nonnull String username, @Nonnull UUID uuid) { + Objects.requireNonNull(username, "username"); + Objects.requireNonNull(uuid, "uuid"); + return this.handle.noBuffer().saveUUIDData(uuid, checkUsername(username)).thenApply(x -> true); } + @Nonnull @Override - public CompletableFuture getUUID(@NonNull String username) { - return handle.noBuffer().getUUID(checkUsername(username)); + public CompletableFuture getUUID(@Nonnull String username) { + Objects.requireNonNull(username, "username"); + return this.handle.noBuffer().getUUID(checkUsername(username)); } + @Nonnull @Override - public CompletableFuture getName(@NonNull UUID uuid) { - return handle.noBuffer().getName(uuid); + public CompletableFuture getName(@Nonnull UUID uuid) { + Objects.requireNonNull(uuid, "uuid"); + return this.handle.noBuffer().getName(uuid); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiTrack.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiTrack.java index ceefb7150..71fbb7c60 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiTrack.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiTrack.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.common.api.delegates.model; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.NonNull; - import com.google.common.base.Preconditions; import me.lucko.luckperms.api.DataMutateResult; @@ -37,94 +32,115 @@ import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.Track; import java.util.List; +import java.util.Objects; + +import javax.annotation.Nonnull; -@AllArgsConstructor public final class ApiTrack implements Track { - public static me.lucko.luckperms.common.model.Track cast(Track g) { - Preconditions.checkState(g instanceof ApiTrack, "Illegal instance " + g.getClass() + " cannot be handled by this implementation."); - return ((ApiTrack) g).getHandle(); + public static me.lucko.luckperms.common.model.Track cast(Track track) { + Objects.requireNonNull(track, "track"); + Preconditions.checkState(track instanceof ApiTrack, "Illegal instance " + track.getClass() + " cannot be handled by this implementation."); + return ((ApiTrack) track).getHandle(); } - @Getter(AccessLevel.PACKAGE) private final me.lucko.luckperms.common.model.Track handle; + + public ApiTrack(me.lucko.luckperms.common.model.Track handle) { + this.handle = handle; + } + me.lucko.luckperms.common.model.Track getHandle() { + return this.handle; + } + + @Nonnull @Override public String getName() { - return handle.getName(); + return this.handle.getName(); } + @Nonnull @Override public List getGroups() { - return handle.getGroups(); + return this.handle.getGroups(); } @Override public int getSize() { - return handle.getSize(); + return this.handle.getSize(); } @Override - public String getNext(@NonNull Group current) { + public String getNext(@Nonnull Group current) { + Objects.requireNonNull(current, "current"); try { - return handle.getNext(ApiGroup.cast(current)); + return this.handle.getNext(ApiGroup.cast(current)); } catch (IllegalArgumentException e) { return null; } } @Override - public String getPrevious(@NonNull Group current) { + public String getPrevious(@Nonnull Group current) { + Objects.requireNonNull(current, "current"); try { - return handle.getPrevious(ApiGroup.cast(current)); + return this.handle.getPrevious(ApiGroup.cast(current)); } catch (IllegalArgumentException e) { return null; } } @Override - public DataMutateResult appendGroup(@NonNull Group group) { - return handle.appendGroup(ApiGroup.cast(group)); + public DataMutateResult appendGroup(@Nonnull Group group) { + Objects.requireNonNull(group, "group"); + return this.handle.appendGroup(ApiGroup.cast(group)); } @Override - public DataMutateResult insertGroup(@NonNull Group group, @NonNull int position) throws IndexOutOfBoundsException { - return handle.insertGroup(ApiGroup.cast(group), position); + public DataMutateResult insertGroup(@Nonnull Group group, int position) throws IndexOutOfBoundsException { + Objects.requireNonNull(group, "group"); + return this.handle.insertGroup(ApiGroup.cast(group), position); } @Override - public DataMutateResult removeGroup(@NonNull Group group) { - return handle.removeGroup(ApiGroup.cast(group)); + public DataMutateResult removeGroup(@Nonnull Group group) { + Objects.requireNonNull(group, "group"); + return this.handle.removeGroup(ApiGroup.cast(group)); } @Override - public DataMutateResult removeGroup(@NonNull String group) { - return handle.removeGroup(group); + public DataMutateResult removeGroup(@Nonnull String group) { + Objects.requireNonNull(group, "group"); + return this.handle.removeGroup(group); } @Override - public boolean containsGroup(@NonNull Group group) { - return handle.containsGroup(ApiGroup.cast(group)); + public boolean containsGroup(@Nonnull Group group) { + Objects.requireNonNull(group, "group"); + return this.handle.containsGroup(ApiGroup.cast(group)); } @Override - public boolean containsGroup(@NonNull String group) { - return handle.containsGroup(group); + public boolean containsGroup(@Nonnull String group) { + Objects.requireNonNull(group, "group"); + return this.handle.containsGroup(group); } @Override public void clearGroups() { - handle.clearGroups(); + this.handle.clearGroups(); } + @Override public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof ApiTrack)) return false; - - ApiTrack other = (ApiTrack) o; - return handle.equals(other.handle); + ApiTrack that = (ApiTrack) o; + return this.handle.equals(that.handle); } + @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiUser.java b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiUser.java index 1b4c02ed9..53b965972 100644 --- a/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiUser.java +++ b/common/src/main/java/me/lucko/luckperms/common/api/delegates/model/ApiUser.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.api.delegates.model; -import lombok.Getter; -import lombok.NonNull; - import com.google.common.base.Preconditions; import me.lucko.luckperms.api.DataMutateResult; @@ -35,77 +32,89 @@ import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.caching.UserData; import me.lucko.luckperms.common.node.NodeFactory; +import java.util.Objects; import java.util.UUID; +import javax.annotation.Nonnull; + public final class ApiUser extends ApiPermissionHolder implements User { public static me.lucko.luckperms.common.model.User cast(User u) { Preconditions.checkState(u instanceof ApiUser, "Illegal instance " + u.getClass() + " cannot be handled by this implementation."); return ((ApiUser) u).getHandle(); } - @Getter private final me.lucko.luckperms.common.model.User handle; - public ApiUser(@NonNull me.lucko.luckperms.common.model.User handle) { + @Override + me.lucko.luckperms.common.model.User getHandle() { + return this.handle; + } + + public ApiUser(me.lucko.luckperms.common.model.User handle) { super(handle); this.handle = handle; } + @Nonnull @Override public UUID getUuid() { - return handle.getUuid(); + return this.handle.getUuid(); } @Override public String getName() { - return handle.getName().orElse(null); + return this.handle.getName().orElse(null); } + @Nonnull @Override public String getPrimaryGroup() { - return handle.getPrimaryGroup().getValue(); + return this.handle.getPrimaryGroup().getValue(); } @Override - public DataMutateResult setPrimaryGroup(@NonNull String s) { - if (getPrimaryGroup().equalsIgnoreCase(s)) { + public DataMutateResult setPrimaryGroup(@Nonnull String group) { + Objects.requireNonNull(group, "group"); + if (getPrimaryGroup().equalsIgnoreCase(group)) { return DataMutateResult.ALREADY_HAS; } - if (!handle.hasPermission(NodeFactory.buildGroupNode(s.toLowerCase()).build()).asBoolean()) { + if (!this.handle.hasPermission(NodeFactory.buildGroupNode(group.toLowerCase()).build()).asBoolean()) { return DataMutateResult.FAIL; } - handle.getPrimaryGroup().setStoredValue(s.toLowerCase()); + this.handle.getPrimaryGroup().setStoredValue(group.toLowerCase()); return DataMutateResult.SUCCESS; } + @Nonnull @Override public UserData getCachedData() { - return handle.getCachedData(); + return this.handle.getCachedData(); } @Override @Deprecated public void refreshPermissions() { - handle.getRefreshBuffer().requestDirectly(); + this.handle.getRefreshBuffer().requestDirectly(); } @Override @Deprecated public void setupDataCache() { - handle.preCalculateData(); + this.handle.preCalculateData(); } + @Override public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof ApiUser)) return false; - - ApiUser other = (ApiUser) o; - return handle.equals(other.handle); + ApiUser that = (ApiUser) o; + return this.handle.equals(that.handle); } + @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentExpression.java b/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentExpression.java index cfd35d96e..d54530332 100644 --- a/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentExpression.java +++ b/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentExpression.java @@ -62,7 +62,7 @@ public class AssignmentExpression { Predicate checker = node -> holder.hasPermission(node) == tristate; - String exp = expression.stream().map(t -> t.forExpression(checker)).collect(Collectors.joining()) + String exp = this.expression.stream().map(t -> t.forExpression(checker)).collect(Collectors.joining()) .replace("&", "&&").replace("|", "||"); try { @@ -123,12 +123,12 @@ public class AssignmentExpression { @Override public String forExpression(Predicate checker) { - return string; + return this.string; } @Override public String toString() { - return string; + return this.string; } } @@ -143,12 +143,12 @@ public class AssignmentExpression { @Override public String forExpression(Predicate checker) { - return Boolean.toString(checker.test(node)); + return Boolean.toString(checker.test(this.node)); } @Override public String toString() { - return "<" + permission + ">"; + return "<" + this.permission + ">"; } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentRule.java b/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentRule.java index 3b6d2d15e..36d9a1e6f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentRule.java +++ b/common/src/main/java/me/lucko/luckperms/common/assignments/AssignmentRule.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.assignments; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.model.User; @@ -36,8 +33,6 @@ import me.lucko.luckperms.common.utils.ImmutableCollectors; import java.util.List; -@Getter -@ToString public class AssignmentRule { private final AssignmentExpression hasTrueExpression; private final AssignmentExpression hasFalseExpression; @@ -57,9 +52,9 @@ public class AssignmentRule { } public boolean apply(User user) { - if (hasTrueExpression != null) { + if (this.hasTrueExpression != null) { try { - boolean b = hasTrueExpression.parse(user, Tristate.TRUE); + boolean b = this.hasTrueExpression.parse(user, Tristate.TRUE); if (!b) { // The holder does not meet this requirement return false; @@ -71,9 +66,9 @@ public class AssignmentRule { } } - if (hasFalseExpression != null) { + if (this.hasFalseExpression != null) { try { - boolean b = hasFalseExpression.parse(user, Tristate.FALSE); + boolean b = this.hasFalseExpression.parse(user, Tristate.FALSE); if (!b) { // The holder does not meet this requirement return false; @@ -85,9 +80,9 @@ public class AssignmentRule { } } - if (lacksExpression != null) { + if (this.lacksExpression != null) { try { - boolean b = lacksExpression.parse(user, Tristate.UNDEFINED); + boolean b = this.lacksExpression.parse(user, Tristate.UNDEFINED); if (!b) { // The holder does not meet this requirement return false; @@ -100,18 +95,53 @@ public class AssignmentRule { } // The holder meets all of the requirements of this rule. - for (Node n : toTake) { + for (Node n : this.toTake) { user.unsetPermission(n); } - for (Node n : toGive) { + for (Node n : this.toGive) { user.setPermission(n); } - if (setPrimaryGroup != null) { - user.getPrimaryGroup().setStoredValue(setPrimaryGroup); + if (this.setPrimaryGroup != null) { + user.getPrimaryGroup().setStoredValue(this.setPrimaryGroup); } return true; } + + public AssignmentExpression getHasTrueExpression() { + return this.hasTrueExpression; + } + + public AssignmentExpression getHasFalseExpression() { + return this.hasFalseExpression; + } + + public AssignmentExpression getLacksExpression() { + return this.lacksExpression; + } + + public List getToGive() { + return this.toGive; + } + + public List getToTake() { + return this.toTake; + } + + public String getSetPrimaryGroup() { + return this.setPrimaryGroup; + } + + @Override + public String toString() { + return "AssignmentRule(" + + "hasTrueExpression=" + this.getHasTrueExpression() + ", " + + "hasFalseExpression=" + this.getHasFalseExpression() + ", " + + "lacksExpression=" + this.getLacksExpression() + ", " + + "toGive=" + this.getToGive() + ", " + + "toTake=" + this.getToTake() + ", " + + "setPrimaryGroup=" + this.getSetPrimaryGroup() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/backup/DummySender.java b/common/src/main/java/me/lucko/luckperms/common/backup/DummySender.java index e665f7368..2af7f6894 100644 --- a/common/src/main/java/me/lucko/luckperms/common/backup/DummySender.java +++ b/common/src/main/java/me/lucko/luckperms/common/backup/DummySender.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.backup; -import lombok.Getter; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.commands.CommandManager; import me.lucko.luckperms.common.commands.sender.Sender; @@ -37,7 +35,6 @@ import net.kyori.text.Component; import java.util.UUID; -@Getter public abstract class DummySender implements Sender { private final LuckPermsPlugin platform; @@ -77,4 +74,18 @@ public abstract class DummySender implements Sender { return true; } + @Override + public LuckPermsPlugin getPlatform() { + return this.platform; + } + + @Override + public UUID getUuid() { + return this.uuid; + } + + @Override + public String getName() { + return this.name; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/backup/Exporter.java b/common/src/main/java/me/lucko/luckperms/common/backup/Exporter.java index cddc21382..72cfdadc0 100644 --- a/common/src/main/java/me/lucko/luckperms/common/backup/Exporter.java +++ b/common/src/main/java/me/lucko/luckperms/common/backup/Exporter.java @@ -83,29 +83,29 @@ public class Exporter implements Runnable { this.executor = executor; this.filePath = filePath; - log = new ProgressLogger(null, Message.EXPORT_LOG, Message.EXPORT_LOG_PROGRESS); - log.addListener(plugin.getConsoleSender()); - log.addListener(executor); + this.log = new ProgressLogger(null, Message.EXPORT_LOG, Message.EXPORT_LOG_PROGRESS); + this.log.addListener(plugin.getConsoleSender()); + this.log.addListener(executor); } @Override public void run() { - try (BufferedWriter writer = Files.newBufferedWriter(filePath, StandardCharsets.UTF_8)) { - log.log("Starting."); + try (BufferedWriter writer = Files.newBufferedWriter(this.filePath, StandardCharsets.UTF_8)) { + this.log.log("Starting."); write(writer, "# LuckPerms Export File"); - write(writer, "# Generated by " + executor.getNameWithLocation() + " at " + DATE_FORMAT.format(new Date(System.currentTimeMillis()))); + write(writer, "# Generated by " + this.executor.getNameWithLocation() + " at " + DATE_FORMAT.format(new Date(System.currentTimeMillis()))); write(writer, ""); // Export Groups - log.log("Starting group export."); + this.log.log("Starting group export."); // Create the actual groups first write(writer, "# Create groups"); AtomicInteger groupCount = new AtomicInteger(0); - List groups = plugin.getGroupManager().getAll().values().stream() + List groups = this.plugin.getGroupManager().getAll().values().stream() // export groups in order of weight .sorted((o1, o2) -> { int i = Integer.compare(o2.getWeight().orElse(0), o1.getWeight().orElse(0)); @@ -128,18 +128,18 @@ public class Exporter implements Runnable { write(writer, "/lp " + NodeFactory.nodeAsCommand(node, group.getName(), HolderType.GROUP, true)); } write(writer, ""); - log.logAllProgress("Exported {} groups so far.", groupCount.incrementAndGet()); + this.log.logAllProgress("Exported {} groups so far.", groupCount.incrementAndGet()); } - log.log("Exported " + groupCount.get() + " groups."); + this.log.log("Exported " + groupCount.get() + " groups."); write(writer, ""); write(writer, ""); // Export tracks - log.log("Starting track export."); + this.log.log("Starting track export."); - Collection tracks = plugin.getTrackManager().getAll().values(); + Collection tracks = this.plugin.getTrackManager().getAll().values(); if (!tracks.isEmpty()) { // Create the actual tracks first @@ -151,32 +151,32 @@ public class Exporter implements Runnable { write(writer, ""); AtomicInteger trackCount = new AtomicInteger(0); - for (Track track : plugin.getTrackManager().getAll().values()) { + for (Track track : this.plugin.getTrackManager().getAll().values()) { write(writer, "# Export track: " + track.getName()); for (String group : track.getGroups()) { write(writer, "/lp track " + track.getName() + " append " + group); } write(writer, ""); - log.logAllProgress("Exported {} tracks so far.", trackCount.incrementAndGet()); + this.log.logAllProgress("Exported {} tracks so far.", trackCount.incrementAndGet()); } write(writer, ""); write(writer, ""); } - log.log("Exported " + tracks.size() + " tracks."); + this.log.log("Exported " + tracks.size() + " tracks."); // Users are migrated in separate threads. // This is because there are likely to be a lot of them, and because we can. // It's a big speed improvement, since the database/files are split up and can handle concurrent reads. - log.log("Starting user export. Finding a list of unique users to export."); + this.log.log("Starting user export. Finding a list of unique users to export."); // Find all of the unique users we need to export - Storage ds = plugin.getStorage(); + Storage ds = this.plugin.getStorage(); Set users = ds.getUniqueUsers().join(); - log.log("Found " + users.size() + " unique users to export."); + this.log.log("Found " + users.size() + " unique users to export."); write(writer, "# Export users"); @@ -186,7 +186,7 @@ public class Exporter implements Runnable { userPools.next().add(uuid); } - log.log("Split users into " + userPools.getBacking().size() + " threads for export."); + this.log.log("Split users into " + userPools.getBacking().size() + " threads for export."); // Setup a file writing lock. We don't want multiple threads writing at the same time. // The write function accepts a list of strings, as we want a user's data to be grouped together. @@ -220,8 +220,8 @@ public class Exporter implements Runnable { // actually export the user. this output will be fed to the writing function when we have all of the user's data. List output = new ArrayList<>(); - plugin.getStorage().loadUser(uuid, null).join(); - User user = plugin.getUserManager().getIfLoaded(uuid); + this.plugin.getStorage().loadUser(uuid, null).join(); + User user = this.plugin.getUserManager().getIfLoaded(uuid); output.add("# Export user: " + user.getUuid().toString() + " - " + user.getName().orElse("unknown username")); boolean inDefault = false; @@ -242,25 +242,25 @@ public class Exporter implements Runnable { output.add("/lp user " + user.getUuid().toString() + " parent remove default"); } - plugin.getUserManager().cleanup(user); + this.plugin.getUserManager().cleanup(user); writeFunction.accept(output); - log.logProgress("Exported {} users so far.", userCount.incrementAndGet()); + this.log.logProgress("Exported {} users so far.", userCount.incrementAndGet()); } catch (Exception e) { e.printStackTrace(); } } - }, plugin.getScheduler().async())); + }, this.plugin.getScheduler().async())); } // all of the threads have been scheduled now and are running. we just need to wait for them all to complete CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()])).join(); - log.log("Exported " + userCount.get() + " users."); + this.log.log("Exported " + userCount.get() + " users."); writer.flush(); - log.getListeners().forEach(l -> Message.LOG_EXPORT_SUCCESS.send(l, filePath.toFile().getAbsolutePath())); + this.log.getListeners().forEach(l -> Message.LOG_EXPORT_SUCCESS.send(l, this.filePath.toFile().getAbsolutePath())); } catch (Exception e) { e.printStackTrace(); diff --git a/common/src/main/java/me/lucko/luckperms/common/backup/Importer.java b/common/src/main/java/me/lucko/luckperms/common/backup/Importer.java index 853dd9c85..d6744d456 100644 --- a/common/src/main/java/me/lucko/luckperms/common/backup/Importer.java +++ b/common/src/main/java/me/lucko/luckperms/common/backup/Importer.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.backup; -import lombok.Getter; -import lombok.Setter; - import com.google.common.base.Splitter; import com.google.common.collect.ImmutableSet; @@ -81,13 +78,13 @@ public class Importer implements Runnable { @Override public void run() { long startTime = System.currentTimeMillis(); - notify.forEach(s -> Message.IMPORT_START.send(s)); + this.notify.forEach(s -> Message.IMPORT_START.send(s)); // form instances for all commands, and register them int index = 1; - for (String command : commands) { - ImportCommand cmd = new ImportCommand(commandManager, index, command); - toExecute.add(cmd); + for (String command : this.commands) { + ImportCommand cmd = new ImportCommand(this.commandManager, index, command); + this.toExecute.add(cmd); if (cmd.getCommand().startsWith("creategroup ") || cmd.getCommand().startsWith("createtrack ")) { cmd.process(); // process immediately @@ -100,7 +97,7 @@ public class Importer implements Runnable { Cycle> commandPools = new Cycle<>(CommandUtils.nInstances(128, ArrayList::new)); String lastTarget = null; - for (ImportCommand cmd : toExecute) { + for (ImportCommand cmd : this.toExecute) { // if the last target isn't the same, skip to a new pool if (lastTarget == null || !lastTarget.equals(cmd.getTarget())) { commandPools.next(); @@ -126,7 +123,7 @@ public class Importer implements Runnable { cmd.process(); processedCount.incrementAndGet(); } - }, commandManager.getPlugin().getScheduler().async())); + }, this.commandManager.getPlugin().getScheduler().async())); } // all of the threads have been scheduled now and are running. we just need to wait for them all to complete @@ -153,24 +150,24 @@ public class Importer implements Runnable { long endTime = System.currentTimeMillis(); double seconds = (endTime - startTime) / 1000; - int errors = (int) toExecute.stream().filter(v -> !v.getResult().asBoolean()).count(); + int errors = (int) this.toExecute.stream().filter(v -> !v.getResult().asBoolean()).count(); switch (errors) { case 0: - notify.forEach(s -> Message.IMPORT_END_COMPLETE.send(s, seconds)); + this.notify.forEach(s -> Message.IMPORT_END_COMPLETE.send(s, seconds)); break; case 1: - notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR_SIN.send(s, seconds, errors)); + this.notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR_SIN.send(s, seconds, errors)); break; default: - notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR.send(s, seconds, errors)); + this.notify.forEach(s -> Message.IMPORT_END_COMPLETE_ERR.send(s, seconds, errors)); break; } AtomicInteger errIndex = new AtomicInteger(1); - for (ImportCommand e : toExecute) { + for (ImportCommand e : this.toExecute) { if (e.getResult() != null && !e.getResult().asBoolean()) { - notify.forEach(s -> { + this.notify.forEach(s -> { Message.IMPORT_END_ERROR_HEADER.send(s, errIndex.get(), e.getId(), e.getCommand(), e.getResult().toString()); for (String out : e.getOutput()) { Message.IMPORT_END_ERROR_CONTENT.send(s, out); @@ -184,17 +181,16 @@ public class Importer implements Runnable { } private void sendProgress(int processedCount) { - int percent = (processedCount * 100) / commands.size(); - int errors = (int) toExecute.stream().filter(v -> v.isCompleted() && !v.getResult().asBoolean()).count(); + int percent = (processedCount * 100) / this.commands.size(); + int errors = (int) this.toExecute.stream().filter(v -> v.isCompleted() && !v.getResult().asBoolean()).count(); if (errors == 1) { - notify.forEach(s -> Message.IMPORT_PROGRESS_SIN.send(s, percent, processedCount, commands.size(), errors)); + this.notify.forEach(s -> Message.IMPORT_PROGRESS_SIN.send(s, percent, processedCount, this.commands.size(), errors)); } else { - notify.forEach(s -> Message.IMPORT_PROGRESS.send(s, percent, processedCount, commands.size(), errors)); + this.notify.forEach(s -> Message.IMPORT_PROGRESS.send(s, percent, processedCount, this.commands.size(), errors)); } } - @Getter private static class ImportCommand extends DummySender { private static final Splitter ARGUMENT_SPLITTER = Splitter.on(CommandManager.COMMAND_SEPARATOR_PATTERN).omitEmptyStrings(); private static final Splitter SPACE_SPLITTER = Splitter.on(" "); @@ -205,12 +201,10 @@ public class Importer implements Runnable { private final String target; - @Setter private boolean completed = false; private final List output = new ArrayList<>(); - @Setter private CommandResult result = CommandResult.FAILURE; ImportCommand(CommandManager commandManager, int id, String command) { @@ -223,7 +217,7 @@ public class Importer implements Runnable { @Override protected void consumeMessage(String s) { - output.add(s); + this.output.add(s); } public void process() { @@ -233,7 +227,7 @@ public class Importer implements Runnable { try { List args = CommandManager.stripQuotes(ARGUMENT_SPLITTER.splitToList(getCommand())); - CommandResult result = commandManager.onCommand(this, "lp", args, Runnable::run).get(); + CommandResult result = this.commandManager.onCommand(this, "lp", args, Runnable::run).get(); setResult(result); } catch (Exception e) { setResult(CommandResult.FAILURE); @@ -287,6 +281,37 @@ public class Importer implements Runnable { return null; } + public int getId() { + return this.id; + } + + public String getCommand() { + return this.command; + } + + public String getTarget() { + return this.target; + } + + public boolean isCompleted() { + return this.completed; + } + + public List getOutput() { + return this.output; + } + + public CommandResult getResult() { + return this.result; + } + + public void setCompleted(boolean completed) { + this.completed = completed; + } + + public void setResult(CommandResult result) { + this.result = result; + } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/buffers/Buffer.java b/common/src/main/java/me/lucko/luckperms/common/buffers/Buffer.java index 37a87e61e..3db1987c6 100644 --- a/common/src/main/java/me/lucko/luckperms/common/buffers/Buffer.java +++ b/common/src/main/java/me/lucko/luckperms/common/buffers/Buffer.java @@ -25,15 +25,10 @@ package me.lucko.luckperms.common.buffers; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.NonNull; -import lombok.Setter; - import java.util.LinkedList; import java.util.List; import java.util.ListIterator; +import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.locks.ReentrantLock; import java.util.function.Function; @@ -60,17 +55,19 @@ public class Buffer implements Runnable { this.dequeueFunc = dequeueFunc; } - public CompletableFuture enqueue(@NonNull T t) { - lock.lock(); + public CompletableFuture enqueue(T object) { + Objects.requireNonNull(object, "object"); + + this.lock.lock(); try { - ListIterator> it = buffer.listIterator(); + ListIterator> it = this.buffer.listIterator(); BufferedObject o = null; while (it.hasNext()) { BufferedObject obj = it.next(); - if (obj.getObject().equals(t)) { + if (obj.getObject().equals(object)) { o = obj; it.remove(); break; @@ -78,28 +75,28 @@ public class Buffer implements Runnable { } if (o == null) { - o = new BufferedObject<>(System.currentTimeMillis(), t, new CompletableFuture()); + o = new BufferedObject<>(System.currentTimeMillis(), object, new CompletableFuture()); } else { o.setBufferTime(System.currentTimeMillis()); } - buffer.add(o); + this.buffer.add(o); return o.getFuture(); } finally { - lock.unlock(); + this.lock.unlock(); } } protected R dequeue(T t) { - return dequeueFunc.apply(t); + return this.dequeueFunc.apply(t); } public void flush(long flushTime) { long time = System.currentTimeMillis(); - lock.lock(); + this.lock.lock(); try { - ListIterator> it = buffer.listIterator(buffer.size()); + ListIterator> it = this.buffer.listIterator(this.buffer.size()); while (it.hasPrevious()) { BufferedObject obj = it.previous(); @@ -114,7 +111,7 @@ public class Buffer implements Runnable { } } } finally { - lock.unlock(); + this.lock.unlock(); } } @@ -123,15 +120,45 @@ public class Buffer implements Runnable { flush(DEFAULT_FLUSH_TIME); } - @Getter - @EqualsAndHashCode(of = "object") - @AllArgsConstructor private static final class BufferedObject { - @Setter private long bufferTime; private final T object; private final CompletableFuture future; + public BufferedObject(long bufferTime, T object, CompletableFuture future) { + this.bufferTime = bufferTime; + this.object = object; + this.future = future; + } + + public long getBufferTime() { + return this.bufferTime; + } + + public void setBufferTime(long bufferTime) { + this.bufferTime = bufferTime; + } + + public T getObject() { + return this.object; + } + + public CompletableFuture getFuture() { + return this.future; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof Buffer.BufferedObject)) return false; + final BufferedObject that = (BufferedObject) o; + return Objects.equals(this.getObject(), that.getObject()); + } + + @Override + public int hashCode() { + return Objects.hashCode(this.object); + } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/buffers/BufferedRequest.java b/common/src/main/java/me/lucko/luckperms/common/buffers/BufferedRequest.java index c988c70bc..1933b0eea 100644 --- a/common/src/main/java/me/lucko/luckperms/common/buffers/BufferedRequest.java +++ b/common/src/main/java/me/lucko/luckperms/common/buffers/BufferedRequest.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.buffers; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import java.lang.ref.WeakReference; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; @@ -42,7 +39,6 @@ import java.util.function.Supplier; * * @param the return type */ -@RequiredArgsConstructor public abstract class BufferedRequest { private final long bufferTimeMillis; private final long sleepInterval; @@ -51,23 +47,29 @@ public abstract class BufferedRequest { private WeakReference> processor = null; private final ReentrantLock lock = new ReentrantLock(); + public BufferedRequest(long bufferTimeMillis, long sleepInterval, Executor executor) { + this.bufferTimeMillis = bufferTimeMillis; + this.sleepInterval = sleepInterval; + this.executor = executor; + } + public CompletableFuture request() { - lock.lock(); + this.lock.lock(); try { - if (processor != null) { - Processor p = processor.get(); + if (this.processor != null) { + Processor p = this.processor.get(); if (p != null && p.isUsable()) { return p.getAndExtend(); } } - Processor p = new Processor<>(bufferTimeMillis, sleepInterval, this::perform); - executor.execute(p); - processor = new WeakReference<>(p); + Processor p = new Processor<>(this.bufferTimeMillis, this.sleepInterval, this::perform); + this.executor.execute(p); + this.processor = new WeakReference<>(p); return p.get(); } finally { - lock.unlock(); + this.lock.unlock(); } } @@ -77,62 +79,70 @@ public abstract class BufferedRequest { protected abstract T perform(); - @RequiredArgsConstructor private static class Processor implements Runnable { private final long delayMillis; private final long sleepMillis; private final Supplier supplier; private final ReentrantLock lock = new ReentrantLock(); private final CompletableFuture future = new CompletableFuture<>(); - @Getter private boolean usable = true; private long executionTime; + public Processor(long delayMillis, long sleepMillis, Supplier supplier) { + this.delayMillis = delayMillis; + this.sleepMillis = sleepMillis; + this.supplier = supplier; + } + @Override public void run() { - lock.lock(); + this.lock.lock(); try { - executionTime = System.currentTimeMillis() + delayMillis; + this.executionTime = System.currentTimeMillis() + this.delayMillis; } finally { - lock.unlock(); + this.lock.unlock(); } while (true) { - lock.lock(); + this.lock.lock(); try { - if (System.currentTimeMillis() > executionTime) { - usable = false; + if (System.currentTimeMillis() > this.executionTime) { + this.usable = false; break; } } finally { - lock.unlock(); + this.lock.unlock(); } try { - Thread.sleep(sleepMillis); + Thread.sleep(this.sleepMillis); } catch (InterruptedException e) { e.printStackTrace(); } } - R result = supplier.get(); - future.complete(result); + R result = this.supplier.get(); + this.future.complete(result); } public CompletableFuture get() { - return future; + return this.future; } public CompletableFuture getAndExtend() { - lock.lock(); + this.lock.lock(); try { - executionTime = System.currentTimeMillis() + delayMillis; + this.executionTime = System.currentTimeMillis() + this.delayMillis; } finally { - lock.unlock(); + this.lock.unlock(); } - return future; + return this.future; + } + + public boolean isUsable() { + return this.usable; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/buffers/Cache.java b/common/src/main/java/me/lucko/luckperms/common/buffers/Cache.java index 82e2e3961..6ced4455b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/buffers/Cache.java +++ b/common/src/main/java/me/lucko/luckperms/common/buffers/Cache.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.buffers; -import lombok.RequiredArgsConstructor; - import java.util.Optional; import java.util.concurrent.locks.ReentrantReadWriteLock; @@ -35,58 +33,56 @@ import java.util.concurrent.locks.ReentrantReadWriteLock; * * @param the type being stored */ -@RequiredArgsConstructor public abstract class Cache { private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - private T cached = null; protected abstract T supply(); public final T get() { // try to just read from the cached value - lock.readLock().lock(); + this.lock.readLock().lock(); try { - if (cached != null) { - return cached; + if (this.cached != null) { + return this.cached; } } finally { // we have to release the read lock, as it is not possible // to acquire the write lock whilst holding a read lock - lock.readLock().unlock(); + this.lock.readLock().unlock(); } - lock.writeLock().lock(); + this.lock.writeLock().lock(); try { // Since the lock was unlocked momentarily, we need // to check again for a cached value - if (cached != null) { - return cached; + if (this.cached != null) { + return this.cached; } // call the supplier and set the cached value - cached = supply(); - return cached; + this.cached = supply(); + return this.cached; } finally { - lock.writeLock().unlock(); + this.lock.writeLock().unlock(); } } public final Optional getIfPresent() { - lock.readLock().lock(); + this.lock.readLock().lock(); try { - return Optional.ofNullable(cached); + return Optional.ofNullable(this.cached); } finally { - lock.readLock().unlock(); + this.lock.readLock().unlock(); } } public final void invalidate() { - lock.writeLock().lock(); + this.lock.writeLock().lock(); try { - cached = null; + this.cached = null; } finally { - lock.writeLock().unlock(); + this.lock.writeLock().unlock(); } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/buffers/UpdateTaskBuffer.java b/common/src/main/java/me/lucko/luckperms/common/buffers/UpdateTaskBuffer.java index afa8f1c5d..0085292e3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/buffers/UpdateTaskBuffer.java +++ b/common/src/main/java/me/lucko/luckperms/common/buffers/UpdateTaskBuffer.java @@ -38,7 +38,7 @@ public class UpdateTaskBuffer extends BufferedRequest { @Override protected Void perform() { - new UpdateTask(plugin, false).run(); + new UpdateTask(this.plugin, false).run(); return null; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdate.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdate.java index 70270c765..394132eaa 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdate.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdate.java @@ -25,26 +25,18 @@ package me.lucko.luckperms.common.bulkupdate; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.common.bulkupdate.action.Action; import me.lucko.luckperms.common.bulkupdate.constraint.Constraint; import me.lucko.luckperms.common.node.NodeModel; import java.util.List; +import java.util.Objects; /** * Represents a query to be applied to a set of data. * Queries can either be applied to im-memory sets of data, or converted to SQL syntax to be executed remotely. */ -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor -public class BulkUpdate { +public final class BulkUpdate { // the data types which this query should apply to private final DataType dataType; @@ -55,6 +47,12 @@ public class BulkUpdate { // a set of constraints which data must match to be acted upon private final List constraints; + public BulkUpdate(DataType dataType, Action action, List constraints) { + this.dataType = dataType; + this.action = action; + this.constraints = constraints; + } + /** * Check to see if a Node instance satisfies the constrints of this query * @@ -62,7 +60,7 @@ public class BulkUpdate { * @return true if satisfied */ public boolean satisfiesConstraints(NodeModel node) { - for (Constraint constraint : constraints) { + for (Constraint constraint : this.constraints) { if (!constraint.isSatisfiedBy(node)) { return false; } @@ -81,7 +79,7 @@ public class BulkUpdate { return from; // make no change } - return action.apply(from); + return this.action.apply(from); } /** @@ -97,17 +95,17 @@ public class BulkUpdate { // add the action // (DELETE FROM or UPDATE) - sb.append(action.getAsSql()); + sb.append(this.action.getAsSql()); // if there are no constraints, just return without a WHERE clause - if (constraints.isEmpty()) { + if (this.constraints.isEmpty()) { return sb.append(";").toString(); } // append constraints sb.append(" WHERE"); - for (int i = 0; i < constraints.size(); i++) { - Constraint constraint = constraints.get(i); + for (int i = 0; i < this.constraints.size(); i++) { + Constraint constraint = this.constraints.get(i); sb.append(" "); if (i != 0) { @@ -141,4 +139,39 @@ public class BulkUpdate { return "'" + s + "'"; } + public DataType getDataType() { + return this.dataType; + } + + public Action getAction() { + return this.action; + } + + public List getConstraints() { + return this.constraints; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof BulkUpdate)) return false; + final BulkUpdate that = (BulkUpdate) o; + + return Objects.equals(this.getDataType(), that.getDataType()) && + Objects.equals(this.getAction(), that.getAction()) && + Objects.equals(this.getConstraints(), that.getConstraints()); + } + + @Override + public int hashCode() { + return Objects.hash(getDataType(), getAction(), getConstraints()); + } + + @Override + public String toString() { + return "BulkUpdate(" + + "dataType=" + this.getDataType() + ", " + + "action=" + this.getAction() + ", " + + "constraints=" + this.getConstraints() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdateBuilder.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdateBuilder.java index 4b0ddb837..c89c53e3c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdateBuilder.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/BulkUpdateBuilder.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.bulkupdate; -import lombok.NoArgsConstructor; -import lombok.ToString; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.common.bulkupdate.action.Action; @@ -39,10 +36,12 @@ import java.util.Set; /** * Responsible for building a {@link BulkUpdate} */ -@ToString -@NoArgsConstructor(staticName = "create") public class BulkUpdateBuilder { + public static BulkUpdateBuilder create() { + return new BulkUpdateBuilder(); + } + // the data type this query should affect private DataType dataType = DataType.ALL; @@ -52,6 +51,9 @@ public class BulkUpdateBuilder { // a set of constraints which data must match to be acted upon private final Set constraints = new LinkedHashSet<>(); + private BulkUpdateBuilder() { + } + public BulkUpdateBuilder action(Action action) { this.action = action; return this; @@ -63,15 +65,23 @@ public class BulkUpdateBuilder { } public BulkUpdateBuilder constraint(Constraint constraint) { - constraints.add(constraint); + this.constraints.add(constraint); return this; } public BulkUpdate build() { - if (action == null) { + if (this.action == null) { throw new IllegalStateException("no action specified"); } - return new BulkUpdate(dataType, action, ImmutableList.copyOf(constraints)); + return new BulkUpdate(this.dataType, this.action, ImmutableList.copyOf(this.constraints)); + } + + @Override + public String toString() { + return "BulkUpdateBuilder(" + + "dataType=" + this.dataType + ", " + + "action=" + this.action + ", " + + "constraints=" + this.constraints + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/DataType.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/DataType.java index 5d4b9ceea..4a64acf05 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/DataType.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/DataType.java @@ -25,14 +25,9 @@ package me.lucko.luckperms.common.bulkupdate; -import lombok.AllArgsConstructor; -import lombok.Getter; - /** * Represents the data sets a query should apply to */ -@Getter -@AllArgsConstructor public enum DataType { ALL("all", true, true), @@ -43,4 +38,21 @@ public enum DataType { private final boolean includingUsers; private final boolean includingGroups; + DataType(String name, boolean includingUsers, boolean includingGroups) { + this.name = name; + this.includingUsers = includingUsers; + this.includingGroups = includingGroups; + } + + public String getName() { + return this.name; + } + + public boolean isIncludingUsers() { + return this.includingUsers; + } + + public boolean isIncludingGroups() { + return this.includingGroups; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/DeleteAction.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/DeleteAction.java index b2a6b65f1..350854d04 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/DeleteAction.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/DeleteAction.java @@ -25,13 +25,17 @@ package me.lucko.luckperms.common.bulkupdate.action; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.node.NodeModel; -@AllArgsConstructor(staticName = "create") public class DeleteAction implements Action { + public static DeleteAction create() { + return new DeleteAction(); + } + + private DeleteAction() { + } + @Override public String getName() { return "delete"; diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/UpdateAction.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/UpdateAction.java index 3d6cb732a..b4f73484a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/UpdateAction.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/action/UpdateAction.java @@ -25,21 +25,27 @@ package me.lucko.luckperms.common.bulkupdate.action; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.bulkupdate.BulkUpdate; import me.lucko.luckperms.common.bulkupdate.constraint.QueryField; import me.lucko.luckperms.common.node.NodeModel; -@AllArgsConstructor(staticName = "of") public class UpdateAction implements Action { + public static UpdateAction of(QueryField field, String value) { + return new UpdateAction(field, value); + } + // the field we're updating private final QueryField field; // the new value of the field private final String value; + private UpdateAction(QueryField field, String value) { + this.field = field; + this.value = value; + } + @Override public String getName() { return "update"; @@ -47,13 +53,13 @@ public class UpdateAction implements Action { @Override public NodeModel apply(NodeModel from) { - switch (field) { + switch (this.field) { case PERMISSION: - return from.setPermission(value); + return from.setPermission(this.value); case SERVER: - return from.setServer(value); + return from.setServer(this.value); case WORLD: - return from.setWorld(value); + return from.setWorld(this.value); default: throw new RuntimeException(); } @@ -61,6 +67,6 @@ public class UpdateAction implements Action { @Override public String getAsSql() { - return "UPDATE {table} SET " + field.getSqlName() + "=" + BulkUpdate.escapeStringForSql(value); + return "UPDATE {table} SET " + this.field.getSqlName() + "=" + BulkUpdate.escapeStringForSql(this.value); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/comparisons/ComparisonType.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/comparisons/ComparisonType.java index a55fa67c6..775a0606a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/comparisons/ComparisonType.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/comparisons/ComparisonType.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.bulkupdate.comparisons; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.bulkupdate.comparisons.impl.ComparisonEqual; import me.lucko.luckperms.common.bulkupdate.comparisons.impl.ComparisonNotEqual; import me.lucko.luckperms.common.bulkupdate.comparisons.impl.ComparisonNotSimilar; @@ -35,7 +33,6 @@ import me.lucko.luckperms.common.bulkupdate.comparisons.impl.ComparisonSimilar; /** * An enumeration of all {@link Comparison}s. */ -@AllArgsConstructor public enum ComparisonType { EQUAL("==", new ComparisonEqual()), @@ -46,12 +43,17 @@ public enum ComparisonType { private final String symbol; private final Comparison instance; + ComparisonType(String symbol, Comparison instance) { + this.symbol = symbol; + this.instance = instance; + } + public String getSymbol() { - return symbol; + return this.symbol; } public Comparison getComparison() { - return instance; + return this.instance; } public static ComparisonType parseComparison(String s) { diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/Constraint.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/Constraint.java index 653641a9c..e5158af4a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/Constraint.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/Constraint.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.bulkupdate.constraint; -import lombok.AllArgsConstructor; -import lombok.Getter; - import me.lucko.luckperms.common.bulkupdate.BulkUpdate; import me.lucko.luckperms.common.bulkupdate.comparisons.ComparisonType; import me.lucko.luckperms.common.node.NodeModel; @@ -35,10 +32,12 @@ import me.lucko.luckperms.common.node.NodeModel; /** * Represents a query constraint */ -@Getter -@AllArgsConstructor(staticName = "of") public class Constraint { + public static Constraint of(QueryField field, ComparisonType comparisonType, String value) { + return new Constraint(field, comparisonType, value); + } + // the field this constraint is comparing against private final QueryField field; @@ -48,6 +47,12 @@ public class Constraint { // the expression being compared against private final String value; + private Constraint(QueryField field, ComparisonType comparisonType, String value) { + this.field = field; + this.comparisonType = comparisonType; + this.value = value; + } + /** * Returns if the given node satisfies this constraint * @@ -55,31 +60,42 @@ public class Constraint { * @return true if satisfied */ public boolean isSatisfiedBy(NodeModel node) { - switch (field) { + switch (this.field) { case PERMISSION: - return comparisonType.getComparison().matches(node.getPermission(), value); + return this.comparisonType.getComparison().matches(node.getPermission(), this.value); case SERVER: - return comparisonType.getComparison().matches(node.getServer(), value); + return this.comparisonType.getComparison().matches(node.getServer(), this.value); case WORLD: - return comparisonType.getComparison().matches(node.getWorld(), value); + return this.comparisonType.getComparison().matches(node.getWorld(), this.value); default: throw new RuntimeException(); } } public String getAsSql() { - switch (comparisonType) { + switch (this.comparisonType) { case EQUAL: - return field.getSqlName() + " = " + BulkUpdate.escapeStringForSql(value); + return this.field.getSqlName() + " = " + BulkUpdate.escapeStringForSql(this.value); case NOT_EQUAL: - return field.getSqlName() + " != " + BulkUpdate.escapeStringForSql(value); + return this.field.getSqlName() + " != " + BulkUpdate.escapeStringForSql(this.value); case SIMILAR: - return field.getSqlName() + " LIKE " + BulkUpdate.escapeStringForSql(value); + return this.field.getSqlName() + " LIKE " + BulkUpdate.escapeStringForSql(this.value); case NOT_SIMILAR: - return field.getSqlName() + " NOT LIKE " + BulkUpdate.escapeStringForSql(value); + return this.field.getSqlName() + " NOT LIKE " + BulkUpdate.escapeStringForSql(this.value); default: throw new RuntimeException(); } } + public QueryField getField() { + return this.field; + } + + public ComparisonType getComparisonType() { + return this.comparisonType; + } + + public String getValue() { + return this.value; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/QueryField.java b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/QueryField.java index 1bafd98e8..a36a06cff 100644 --- a/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/QueryField.java +++ b/common/src/main/java/me/lucko/luckperms/common/bulkupdate/constraint/QueryField.java @@ -25,14 +25,9 @@ package me.lucko.luckperms.common.bulkupdate.constraint; -import lombok.AllArgsConstructor; -import lombok.Getter; - /** * Represents a field being used in an update */ -@Getter -@AllArgsConstructor public enum QueryField { PERMISSION("permission"), @@ -48,4 +43,12 @@ public enum QueryField { return null; } } + + QueryField(String sqlName) { + this.sqlName = sqlName; + } + + public String getSqlName() { + return this.sqlName; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/GroupCachedData.java b/common/src/main/java/me/lucko/luckperms/common/caching/GroupCachedData.java index 491f920fb..9198c9428 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/GroupCachedData.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/GroupCachedData.java @@ -39,6 +39,6 @@ public class GroupCachedData extends HolderCachedData implements GroupDat @Override protected String getHolderName() { - return holder.getName(); + return this.holder.getName(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/HolderCachedData.java b/common/src/main/java/me/lucko/luckperms/common/caching/HolderCachedData.java index aec63c31f..fdead0417 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/HolderCachedData.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/HolderCachedData.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.caching; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import com.github.benmanes.caffeine.cache.CacheLoader; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; @@ -46,14 +43,16 @@ import me.lucko.luckperms.common.model.PermissionHolder; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.HashSet; +import java.util.Objects; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit; +import javax.annotation.Nonnull; + /** * Holds an easily accessible cache of a holders data in a number of contexts */ -@RequiredArgsConstructor public abstract class HolderCachedData implements CachedData { /** @@ -75,6 +74,10 @@ public abstract class HolderCachedData implements Ca .expireAfterAccess(2, TimeUnit.MINUTES) .build(new MetaCacheLoader()); + public HolderCachedData(T holder) { + this.holder = holder; + } + protected abstract String getHolderName(); /** @@ -84,16 +87,18 @@ public abstract class HolderCachedData implements Ca * @param data an old data instance to try to reuse - ignored if null * @return the calculated instance */ - private PermissionCache calculatePermissions(@NonNull Contexts contexts, PermissionCache data) { + private PermissionCache calculatePermissions(Contexts contexts, PermissionCache data) { + Objects.requireNonNull(contexts, "contexts"); + if (data == null) { - PermissionCalculatorMetadata metadata = PermissionCalculatorMetadata.of(holder.getType(), getHolderName(), contexts.getContexts()); - data = new PermissionCache(contexts, metadata, holder.getPlugin().getCalculatorFactory()); + PermissionCalculatorMetadata metadata = PermissionCalculatorMetadata.of(this.holder.getType(), getHolderName(), contexts.getContexts()); + data = new PermissionCache(contexts, metadata, this.holder.getPlugin().getCalculatorFactory()); } if (contexts == Contexts.allowAll()) { - data.setPermissions(holder.exportNodesAndShorthand(true)); + data.setPermissions(this.holder.exportNodesAndShorthand(true)); } else { - data.setPermissions(holder.exportNodesAndShorthand(contexts, true)); + data.setPermissions(this.holder.exportNodesAndShorthand(contexts, true)); } return data; @@ -106,122 +111,153 @@ public abstract class HolderCachedData implements Ca * @param data an old data instance to try to reuse - ignored if null * @return the calculated instance */ - private MetaCache calculateMeta(@NonNull MetaContexts contexts, MetaCache data) { + private MetaCache calculateMeta(MetaContexts contexts, MetaCache data) { + Objects.requireNonNull(contexts, "contexts"); + if (data == null) { data = new MetaCache(contexts); } if (contexts.getContexts() == Contexts.allowAll()) { - data.loadMeta(holder.accumulateMeta(newAccumulator(contexts), null)); + data.loadMeta(this.holder.accumulateMeta(newAccumulator(contexts), null)); } else { - data.loadMeta(holder.accumulateMeta(newAccumulator(contexts), null, contexts.getContexts())); + data.loadMeta(this.holder.accumulateMeta(newAccumulator(contexts), null, contexts.getContexts())); } return data; } + @Nonnull @Override - public PermissionCache getPermissionData(@NonNull Contexts contexts) { + public PermissionCache getPermissionData(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + //noinspection ConstantConditions - return permission.get(contexts); + return this.permission.get(contexts); } + @Nonnull @Override - public MetaCache getMetaData(@NonNull MetaContexts contexts) { + public MetaCache getMetaData(@Nonnull MetaContexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + //noinspection ConstantConditions - return meta.get(contexts); + return this.meta.get(contexts); } + @Nonnull @Override - public MetaCache getMetaData(@NonNull Contexts contexts) { - return getMetaData(makeFromMetaContextsConfig(contexts, holder.getPlugin())); + public MetaCache getMetaData(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + return getMetaData(makeFromMetaContextsConfig(contexts, this.holder.getPlugin())); } + @Nonnull @Override - public PermissionCache calculatePermissions(@NonNull Contexts contexts) { + public PermissionCache calculatePermissions(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); return calculatePermissions(contexts, null); } + @Nonnull @Override - public MetaCache calculateMeta(@NonNull MetaContexts contexts) { + public MetaCache calculateMeta(@Nonnull MetaContexts contexts) { + Objects.requireNonNull(contexts, "contexts"); return calculateMeta(contexts, null); } + @Nonnull @Override - public MetaCache calculateMeta(@NonNull Contexts contexts) { - return calculateMeta(makeFromMetaContextsConfig(contexts, holder.getPlugin())); + public MetaCache calculateMeta(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + return calculateMeta(makeFromMetaContextsConfig(contexts, this.holder.getPlugin())); } @Override - public void recalculatePermissions(@NonNull Contexts contexts) { - permission.refresh(contexts); + public void recalculatePermissions(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + this.permission.refresh(contexts); } @Override - public void recalculateMeta(@NonNull MetaContexts contexts) { - meta.refresh(contexts); + public void recalculateMeta(@Nonnull MetaContexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + this.meta.refresh(contexts); } @Override - public void recalculateMeta(@NonNull Contexts contexts) { - recalculateMeta(makeFromMetaContextsConfig(contexts, holder.getPlugin())); + public void recalculateMeta(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + recalculateMeta(makeFromMetaContextsConfig(contexts, this.holder.getPlugin())); } + @Nonnull @Override - public CompletableFuture reloadPermissions(@NonNull Contexts contexts) { + public CompletableFuture reloadPermissions(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + // get the previous value - to use when recalculating - PermissionCache previous = permission.getIfPresent(contexts); + PermissionCache previous = this.permission.getIfPresent(contexts); // invalidate the entry - permission.invalidate(contexts); + this.permission.invalidate(contexts); // repopulate the cache - return CompletableFuture.supplyAsync(() -> permission.get(contexts, c -> calculatePermissions(c, previous))); + return CompletableFuture.supplyAsync(() -> this.permission.get(contexts, c -> calculatePermissions(c, previous))); } + @Nonnull @Override - public CompletableFuture reloadMeta(@NonNull MetaContexts contexts) { + public CompletableFuture reloadMeta(@Nonnull MetaContexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + // get the previous value - to use when recalculating - MetaCache previous = meta.getIfPresent(contexts); + MetaCache previous = this.meta.getIfPresent(contexts); // invalidate the entry - meta.invalidate(contexts); + this.meta.invalidate(contexts); // repopulate the cache - return CompletableFuture.supplyAsync(() -> meta.get(contexts, c -> calculateMeta(c, previous))); + return CompletableFuture.supplyAsync(() -> this.meta.get(contexts, c -> calculateMeta(c, previous))); } + @Nonnull @Override - public CompletableFuture reloadMeta(@NonNull Contexts contexts) { - return reloadMeta(makeFromMetaContextsConfig(contexts, holder.getPlugin())); + public CompletableFuture reloadMeta(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + return reloadMeta(makeFromMetaContextsConfig(contexts, this.holder.getPlugin())); } @Override public void recalculatePermissions() { - Set keys = permission.asMap().keySet(); + Set keys = this.permission.asMap().keySet(); keys.forEach(this::recalculatePermissions); } @Override public void recalculateMeta() { - Set keys = meta.asMap().keySet(); + Set keys = this.meta.asMap().keySet(); keys.forEach(this::recalculateMeta); } + @Nonnull @Override public CompletableFuture reloadPermissions() { - Set keys = new HashSet<>(permission.asMap().keySet()); + Set keys = new HashSet<>(this.permission.asMap().keySet()); return CompletableFuture.allOf(keys.stream().map(this::reloadPermissions).toArray(CompletableFuture[]::new)); } + @Nonnull @Override public CompletableFuture reloadMeta() { - Set keys = new HashSet<>(meta.asMap().keySet()); + Set keys = new HashSet<>(this.meta.asMap().keySet()); return CompletableFuture.allOf(keys.stream().map(this::reloadMeta).toArray(CompletableFuture[]::new)); } @Override - public void preCalculate(@NonNull Contexts contexts) { + public void preCalculate(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + // pre-calculate just by requesting the data from this cache. // if the data isn't already loaded, it will be calculated. getPermissionData(contexts); @@ -229,55 +265,58 @@ public abstract class HolderCachedData implements Ca } @Override - public void invalidatePermissions(Contexts contexts) { - permission.invalidate(contexts); + public void invalidatePermissions(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + this.permission.invalidate(contexts); } @Override - public void invalidateMeta(MetaContexts contexts) { - meta.invalidate(contexts); + public void invalidateMeta(@Nonnull MetaContexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + this.meta.invalidate(contexts); } @Override - public void invalidateMeta(Contexts contexts) { - meta.invalidate(makeFromMetaContextsConfig(contexts, holder.getPlugin())); + public void invalidateMeta(@Nonnull Contexts contexts) { + Objects.requireNonNull(contexts, "contexts"); + this.meta.invalidate(makeFromMetaContextsConfig(contexts, this.holder.getPlugin())); } @Override public void invalidatePermissionCalculators() { - permission.asMap().values().forEach(PermissionCache::invalidateCache); + this.permission.asMap().values().forEach(PermissionCache::invalidateCache); } public void invalidateCaches() { - permission.invalidateAll(); - meta.invalidateAll(); + this.permission.invalidateAll(); + this.meta.invalidateAll(); } public void doCacheCleanup() { - permission.cleanUp(); - meta.cleanUp(); + this.permission.cleanUp(); + this.meta.cleanUp(); } private final class PermissionCacheLoader implements CacheLoader { @Override - public PermissionCache load(Contexts contexts) { + public PermissionCache load(@Nonnull Contexts contexts) { return calculatePermissions(contexts); } @Override - public PermissionCache reload(Contexts contexts, PermissionCache oldData) { + public PermissionCache reload(@Nonnull Contexts contexts, @Nonnull PermissionCache oldData) { return calculatePermissions(contexts, oldData); } } private final class MetaCacheLoader implements CacheLoader { @Override - public MetaCache load(MetaContexts contexts) { + public MetaCache load(@Nonnull MetaContexts contexts) { return calculateMeta(contexts); } @Override - public MetaCache reload(MetaContexts contexts, MetaCache oldData) { + public MetaCache reload(@Nonnull MetaContexts contexts, @Nonnull MetaCache oldData) { return calculateMeta(contexts, oldData); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/UserCachedData.java b/common/src/main/java/me/lucko/luckperms/common/caching/UserCachedData.java index 2992fb1e8..19d89e41d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/UserCachedData.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/UserCachedData.java @@ -39,6 +39,6 @@ public class UserCachedData extends HolderCachedData implements UserData { @Override protected String getHolderName() { - return holder.getFriendlyName(); + return this.holder.getFriendlyName(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/handlers/CachedStateManager.java b/common/src/main/java/me/lucko/luckperms/common/caching/handlers/CachedStateManager.java index 73e5be699..f0399399e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/handlers/CachedStateManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/handlers/CachedStateManager.java @@ -54,7 +54,7 @@ public class CachedStateManager { Set set = new HashSet<>(); set.add(holder); - lock.lock(); + this.lock.lock(); try { while (true) { Set clone = new HashSet<>(set); @@ -62,7 +62,7 @@ public class CachedStateManager { boolean work = false; for (HolderReference s : clone) { - if (set.addAll(map.get(s))) { + if (set.addAll(this.map.get(s))) { work = true; } } @@ -72,7 +72,7 @@ public class CachedStateManager { } } } finally { - lock.unlock(); + this.lock.unlock(); } set.remove(holder); @@ -86,15 +86,15 @@ public class CachedStateManager { * @param inheritedGroups a list of groups the holder inherits from */ public void putAll(HolderReference holder, Set inheritedGroups) { - lock.lock(); + this.lock.lock(); try { - map.entries().removeIf(entry -> entry.getValue().equals(holder)); + this.map.entries().removeIf(entry -> entry.getValue().equals(holder)); for (HolderReference child : inheritedGroups) { - map.put(child, holder); + this.map.put(child, holder); } } finally { - lock.unlock(); + this.lock.unlock(); } } @@ -104,11 +104,11 @@ public class CachedStateManager { * @param holder the holder name to clear */ public void clear(HolderReference holder) { - lock.lock(); + this.lock.lock(); try { - map.entries().removeIf(entry -> entry.getValue().equals(holder)); + this.map.entries().removeIf(entry -> entry.getValue().equals(holder)); } finally { - lock.unlock(); + this.lock.unlock(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaAccumulator.java b/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaAccumulator.java index 87604af90..809354ad4 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaAccumulator.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaAccumulator.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.common.caching.type; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.NonNull; -import lombok.ToString; - import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ListMultimap; @@ -43,6 +38,7 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.Comparator; import java.util.Map; +import java.util.Objects; import java.util.SortedMap; import java.util.TreeMap; @@ -50,8 +46,6 @@ import java.util.TreeMap; * Holds temporary mutable meta whilst this object is passed up the * inheritance tree to accumulate meta from parents */ -@Getter -@ToString public class MetaAccumulator { public static MetaAccumulator makeFromConfig(LuckPermsPlugin plugin) { return new MetaAccumulator( @@ -60,7 +54,6 @@ public class MetaAccumulator { ); } - @Getter(AccessLevel.NONE) private final ListMultimap meta; private final SortedMap prefixes; private final SortedMap suffixes; @@ -69,7 +62,9 @@ public class MetaAccumulator { private final MetaStack prefixStack; private final MetaStack suffixStack; - public MetaAccumulator(@NonNull MetaStack prefixStack, @NonNull MetaStack suffixStack) { + public MetaAccumulator(MetaStack prefixStack, MetaStack suffixStack) { + Objects.requireNonNull(prefixStack, "prefixStack"); + Objects.requireNonNull(suffixStack, "suffixStack"); this.meta = ArrayListMultimap.create(); this.prefixes = new TreeMap<>(Comparator.reverseOrder()); this.suffixes = new TreeMap<>(Comparator.reverseOrder()); @@ -80,19 +75,19 @@ public class MetaAccumulator { public void accumulateNode(LocalizedNode n) { if (n.isMeta()) { Map.Entry entry = n.getMeta(); - meta.put(entry.getKey(), entry.getValue()); + this.meta.put(entry.getKey(), entry.getValue()); } if (n.isPrefix()) { Map.Entry value = n.getPrefix(); - prefixes.putIfAbsent(value.getKey(), value.getValue()); - prefixStack.accumulateToAll(n); + this.prefixes.putIfAbsent(value.getKey(), value.getValue()); + this.prefixStack.accumulateToAll(n); } if (n.isSuffix()) { Map.Entry value = n.getSuffix(); - suffixes.putIfAbsent(value.getKey(), value.getValue()); - suffixStack.accumulateToAll(n); + this.suffixes.putIfAbsent(value.getKey(), value.getValue()); + this.suffixStack.accumulateToAll(n); } } @@ -112,11 +107,41 @@ public class MetaAccumulator { } public Map getChatMeta(ChatMetaType type) { - return type == ChatMetaType.PREFIX ? prefixes : suffixes; + return type == ChatMetaType.PREFIX ? this.prefixes : this.suffixes; } public MetaStack getStack(ChatMetaType type) { - return type == ChatMetaType.PREFIX ? prefixStack : suffixStack; + return type == ChatMetaType.PREFIX ? this.prefixStack : this.suffixStack; } + public SortedMap getPrefixes() { + return this.prefixes; + } + + public SortedMap getSuffixes() { + return this.suffixes; + } + + public int getWeight() { + return this.weight; + } + + public MetaStack getPrefixStack() { + return this.prefixStack; + } + + public MetaStack getSuffixStack() { + return this.suffixStack; + } + + @Override + public String toString() { + return "MetaAccumulator(" + + "meta=" + this.getMeta() + ", " + + "prefixes=" + this.getPrefixes() + ", " + + "suffixes=" + this.getSuffixes() + ", " + + "weight=" + this.getWeight() + ", " + + "prefixStack=" + this.getPrefixStack() + ", " + + "suffixStack=" + this.getSuffixStack() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaCache.java b/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaCache.java index e9d9772f7..47b64e1f3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/type/MetaCache.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.caching.type; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSortedMap; @@ -46,13 +42,12 @@ import java.util.SortedMap; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; +import javax.annotation.Nonnull; + /** * Holds cached meta for a given context */ -@Getter -@RequiredArgsConstructor public class MetaCache implements MetaData { - @Getter(AccessLevel.NONE) private final ReadWriteLock lock = new ReentrantReadWriteLock(); /** @@ -67,8 +62,12 @@ public class MetaCache implements MetaData { private MetaStack prefixStack = null; private MetaStack suffixStack = null; + public MetaCache(MetaContexts metaContexts) { + this.metaContexts = metaContexts; + } + public void loadMeta(MetaAccumulator meta) { - lock.writeLock().lock(); + this.lock.writeLock().lock(); try { this.metaMultimap = ImmutableListMultimap.copyOf(meta.getMeta()); @@ -91,43 +90,76 @@ public class MetaCache implements MetaData { this.prefixStack = meta.getPrefixStack(); this.suffixStack = meta.getSuffixStack(); } finally { - lock.writeLock().unlock(); + this.lock.writeLock().unlock(); } } @Override public String getPrefix() { - lock.readLock().lock(); + this.lock.readLock().lock(); try { - return prefixStack == null ? null : prefixStack.toFormattedString(); + return this.prefixStack == null ? null : this.prefixStack.toFormattedString(); } finally { - lock.readLock().unlock(); + this.lock.readLock().unlock(); } } @Override public String getSuffix() { - lock.readLock().lock(); + this.lock.readLock().lock(); try { - return suffixStack == null ? null : suffixStack.toFormattedString(); + return this.suffixStack == null ? null : this.suffixStack.toFormattedString(); } finally { - lock.readLock().unlock(); + this.lock.readLock().unlock(); } } + @Nonnull @Override public MetaStackDefinition getPrefixStackDefinition() { - return prefixStack.getDefinition(); + return this.prefixStack.getDefinition(); } + @Nonnull @Override public MetaStackDefinition getSuffixStackDefinition() { - return suffixStack.getDefinition(); + return this.suffixStack.getDefinition(); } + @Nonnull @Override public Contexts getContexts() { - return metaContexts.getContexts(); + return this.metaContexts.getContexts(); + } + + @Nonnull + @Override + public MetaContexts getMetaContexts() { + return this.metaContexts; + } + + @Nonnull + @Override + public ListMultimap getMetaMultimap() { + return this.metaMultimap; + } + + @Nonnull + @Override + public Map getMeta() { + return this.meta; + } + + @Nonnull + @Override + public SortedMap getPrefixes() { + return this.prefixes; + } + + @Nonnull + @Override + public SortedMap getSuffixes() { + return this.suffixes; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java b/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java index 1bf2bf3e8..49eaa21a6 100644 --- a/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/caching/type/PermissionCache.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.caching.type; -import lombok.Getter; -import lombok.NonNull; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.caching.PermissionData; @@ -40,6 +37,8 @@ import java.util.Collections; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; +import javax.annotation.Nonnull; + /** * Holds cached permissions data for a given context */ @@ -48,7 +47,6 @@ public class PermissionCache implements PermissionData { /** * The contexts this container is holding data for */ - @Getter private final Contexts contexts; /** @@ -70,42 +68,56 @@ public class PermissionCache implements PermissionData { public PermissionCache(Contexts contexts, PermissionCalculatorMetadata metadata, CalculatorFactory calculatorFactory) { this.contexts = contexts; - permissions = new ConcurrentHashMap<>(); - permissionsUnmodifiable = Collections.unmodifiableMap(permissions); + this.permissions = new ConcurrentHashMap<>(); + this.permissionsUnmodifiable = Collections.unmodifiableMap(this.permissions); - calculator = calculatorFactory.build(contexts, metadata); - calculator.updateBacking(permissions); // Initial setup. + this.calculator = calculatorFactory.build(contexts, metadata); + this.calculator.updateBacking(this.permissions); // Initial setup. } @Override public void invalidateCache() { - calculator.invalidateCache(); + this.calculator.invalidateCache(); } private void setPermissionsInternal(Map permissions) { this.permissions.clear(); this.permissions.putAll(permissions); - calculator.updateBacking(this.permissions); + this.calculator.updateBacking(this.permissions); invalidateCache(); } public void setPermissions(Map toApply) { - if (!permissions.equals(toApply)) { + if (!this.permissions.equals(toApply)) { setPermissionsInternal(toApply); } } + @Nonnull @Override public Map getImmutableBacking() { - return permissionsUnmodifiable; + return this.permissionsUnmodifiable; } + @Nonnull @Override - public Tristate getPermissionValue(@NonNull String permission) { - return calculator.getPermissionValue(permission, CheckOrigin.API); + public Tristate getPermissionValue(@Nonnull String permission) { + if (permission == null) { + throw new NullPointerException("permission"); + } + return this.calculator.getPermissionValue(permission, CheckOrigin.API); } - public Tristate getPermissionValue(@NonNull String permission, CheckOrigin origin) { - return calculator.getPermissionValue(permission, origin); + public Tristate getPermissionValue(String permission, CheckOrigin origin) { + if (permission == null) { + throw new NullPointerException("permission"); + } + return this.calculator.getPermissionValue(permission, origin); + } + + @Nonnull + @Override + public Contexts getContexts() { + return this.contexts; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculators/AbstractCalculatorFactory.java b/common/src/main/java/me/lucko/luckperms/common/calculators/AbstractCalculatorFactory.java index cc0e0615b..9b9cf075f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculators/AbstractCalculatorFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculators/AbstractCalculatorFactory.java @@ -34,13 +34,13 @@ public abstract class AbstractCalculatorFactory implements CalculatorFactory { private final Set calculators = Collections.newSetFromMap(new MapMaker().weakKeys().makeMap()); protected PermissionCalculator registerCalculator(PermissionCalculator calculator) { - calculators.add(calculator); + this.calculators.add(calculator); return calculator; } @Override public void invalidateAll() { - for (PermissionCalculator calculator : calculators) { + for (PermissionCalculator calculator : this.calculators) { calculator.invalidateCache(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java index ebeede406..75a0aa334 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculator.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.calculators; -import lombok.RequiredArgsConstructor; - import com.github.benmanes.caffeine.cache.CacheLoader; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; @@ -39,10 +37,11 @@ import me.lucko.luckperms.common.verbose.CheckOrigin; import java.util.List; import java.util.Map; +import javax.annotation.Nonnull; + /** * Calculates and caches permissions */ -@RequiredArgsConstructor public class PermissionCalculator implements CacheLoader { private final LuckPermsPlugin plugin; private final PermissionCalculatorMetadata metadata; @@ -51,8 +50,14 @@ public class PermissionCalculator implements CacheLoader { // caches lookup calls. private final LoadingCache lookupCache = Caffeine.newBuilder().build(this); + public PermissionCalculator(LuckPermsPlugin plugin, PermissionCalculatorMetadata metadata, List processors) { + this.plugin = plugin; + this.metadata = metadata; + this.processors = processors; + } + public void invalidateCache() { - lookupCache.invalidateAll(); + this.lookupCache.invalidateAll(); } public Tristate getPermissionValue(String permission, CheckOrigin origin) { @@ -62,24 +67,24 @@ public class PermissionCalculator implements CacheLoader { permission = permission.toLowerCase().intern(); // get the result - Tristate result = lookupCache.get(permission); + Tristate result = this.lookupCache.get(permission); // log this permission lookup to the verbose handler - plugin.getVerboseHandler().offerCheckData(origin, metadata.getObjectName(), metadata.getContext(), permission, result); + this.plugin.getVerboseHandler().offerCheckData(origin, this.metadata.getObjectName(), this.metadata.getContext(), permission, result); // return the result return result; } @Override - public Tristate load(String permission) { + public Tristate load(@Nonnull String permission) { // offer the permission to the permission vault // we only need to do this once per permission, so it doesn't matter // that this call is behind the cache. - plugin.getPermissionVault().offer(permission); + this.plugin.getPermissionVault().offer(permission); - for (PermissionProcessor processor : processors) { + for (PermissionProcessor processor : this.processors) { Tristate result = processor.hasPermission(permission); if (result == Tristate.UNDEFINED) { continue; @@ -92,7 +97,7 @@ public class PermissionCalculator implements CacheLoader { } public synchronized void updateBacking(Map map) { - for (PermissionProcessor processor : processors) { + for (PermissionProcessor processor : this.processors) { processor.updateBacking(map); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java index 753c2f0f5..c023562d4 100644 --- a/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java +++ b/common/src/main/java/me/lucko/luckperms/common/calculators/PermissionCalculatorMetadata.java @@ -25,16 +25,15 @@ package me.lucko.luckperms.common.calculators; -import lombok.AllArgsConstructor; -import lombok.Getter; - import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.common.references.HolderType; -@Getter -@AllArgsConstructor(staticName = "of") public class PermissionCalculatorMetadata { + public static PermissionCalculatorMetadata of(HolderType holderType, String objectName, ContextSet context) { + return new PermissionCalculatorMetadata(holderType, objectName, context); + } + /** * The type of the object which owns the permission calculator */ @@ -50,4 +49,21 @@ public class PermissionCalculatorMetadata { */ private final ContextSet context; + private PermissionCalculatorMetadata(HolderType holderType, String objectName, ContextSet context) { + this.holderType = holderType; + this.objectName = objectName; + this.context = context; + } + + public HolderType getHolderType() { + return this.holderType; + } + + public String getObjectName() { + return this.objectName; + } + + public ContextSet getContext() { + return this.context; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/Arg.java b/common/src/main/java/me/lucko/luckperms/common/commands/Arg.java index 412bef8b5..bdb1f2aff 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/Arg.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/Arg.java @@ -25,14 +25,8 @@ package me.lucko.luckperms.common.commands; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; - import com.google.common.collect.ImmutableList; -@Getter -@AllArgsConstructor(access = AccessLevel.PRIVATE) public class Arg { public static Arg create(String name, boolean required, String description) { return new Arg(name, required, description); @@ -46,8 +40,25 @@ public class Arg { private final boolean required; private final String description; - public String asPrettyString() { - return required ? "&8<&7" + name + "&8>" : "&8[&7" + name + "&8]"; + private Arg(String name, boolean required, String description) { + this.name = name; + this.required = required; + this.description = description; } + public String asPrettyString() { + return this.required ? "&8<&7" + this.name + "&8>" : "&8[&7" + this.name + "&8]"; + } + + public String getName() { + return this.name; + } + + public boolean isRequired() { + return this.required; + } + + public String getDescription() { + return this.description; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/ArgumentPermissions.java b/common/src/main/java/me/lucko/luckperms/common/commands/ArgumentPermissions.java index 24d56c46a..214c34a4f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/ArgumentPermissions.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/ArgumentPermissions.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.commands; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.common.commands.sender.Sender; @@ -40,8 +38,7 @@ import java.util.Map; import java.util.function.BiFunction; import java.util.function.Function; -@UtilityClass -public class ArgumentPermissions { +public final class ArgumentPermissions { private static final String USER_MODIFY_SELF = CommandPermission.ROOT + "modify.user.self"; private static final String USER_MODIFY_OTHERS = CommandPermission.ROOT + "modify.user.others"; private static final Function GROUP_MODIFY = s -> CommandPermission.ROOT + "modify.group." + s; @@ -217,5 +214,7 @@ public class ArgumentPermissions { return false; } + + private ArgumentPermissions() {} } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/CommandManager.java b/common/src/main/java/me/lucko/luckperms/common/commands/CommandManager.java index 005ed93f4..d673a91a9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/CommandManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/CommandManager.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.commands; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.common.commands.abstraction.Command; @@ -90,13 +88,11 @@ public class CommandManager { public static final char SECTION_CHAR = '\u00A7'; // § public static final char AMPERSAND_CHAR = '&'; - @Getter private final LuckPermsPlugin plugin; // the default executor to run commands on private final ExecutorService executor = Executors.newSingleThreadExecutor(); - @Getter private final List mainCommands; public CommandManager(LuckPermsPlugin plugin) { @@ -104,7 +100,7 @@ public class CommandManager { LocaleManager locale = plugin.getLocaleManager(); - mainCommands = ImmutableList.builder() + this.mainCommands = ImmutableList.builder() .add(new UserMainCommand(locale)) .add(new GroupMainCommand(locale)) .add(new TrackMainCommand(locale)) @@ -132,8 +128,12 @@ public class CommandManager { .build(); } + public LuckPermsPlugin getPlugin() { + return this.plugin; + } + public CompletableFuture onCommand(Sender sender, String label, List args) { - return onCommand(sender, label, args, executor); + return onCommand(sender, label, args, this.executor); } public CompletableFuture onCommand(Sender sender, String label, List args, Executor executor) { @@ -141,7 +141,7 @@ public class CommandManager { try { return execute(sender, label, args); } catch (Throwable e) { - plugin.getLog().severe("Exception whilst executing command: " + args.toString()); + this.plugin.getLog().severe("Exception whilst executing command: " + args.toString()); e.printStackTrace(); return null; } @@ -154,9 +154,9 @@ public class CommandManager { handleRewrites(arguments, true); // Handle no arguments - if (arguments.size() == 0 || (arguments.size() == 1 && arguments.get(0).trim().isEmpty())) { - CommandUtils.sendPluginMessage(sender, "&2Running &bLuckPerms v" + plugin.getVersion() + "&2."); - if (mainCommands.stream().anyMatch(c -> c.shouldDisplay() && c.isAuthorized(sender))) { + if (arguments.isEmpty() || (arguments.size() == 1 && arguments.get(0).trim().isEmpty())) { + CommandUtils.sendPluginMessage(sender, "&2Running &bLuckPerms v" + this.plugin.getVersion() + "&2."); + if (this.mainCommands.stream().anyMatch(c -> c.shouldDisplay() && c.isAuthorized(sender))) { Message.VIEW_AVAILABLE_COMMANDS_PROMPT.send(sender, label); } else { Message.NO_PERMISSION_FOR_SUBCOMMANDS.send(sender); @@ -165,7 +165,7 @@ public class CommandManager { } // Look for the main command. - Optional o = mainCommands.stream() + Optional o = this.mainCommands.stream() .filter(m -> m.getName().equalsIgnoreCase(arguments.get(0))) .limit(1) .findAny(); @@ -194,7 +194,7 @@ public class CommandManager { // Try to execute the command. CommandResult result; try { - result = main.execute(plugin, sender, null, arguments, label); + result = main.execute(this.plugin, sender, null, arguments, label); } catch (CommandException e) { result = handleException(e, sender, label, main); } catch (Throwable e) { @@ -219,7 +219,7 @@ public class CommandManager { // we rewrite tab completions too! handleRewrites(arguments, false); - final List mains = mainCommands.stream() + final List mains = this.mainCommands.stream() .filter(Command::shouldDisplay) .filter(m -> m.isAuthorized(sender)) .collect(Collectors.toList()); @@ -249,12 +249,12 @@ public class CommandManager { arguments.remove(0); // remove the main command arg. // Pass the processing onto the main command - return o.map(cmd -> cmd.tabComplete(plugin, sender, arguments)).orElseGet(Collections::emptyList); + return o.map(cmd -> cmd.tabComplete(this.plugin, sender, arguments)).orElseGet(Collections::emptyList); } private void sendCommandUsage(Sender sender, String label) { - CommandUtils.sendPluginMessage(sender, "&2Running &bLuckPerms v" + plugin.getVersion() + "&2."); - mainCommands.stream() + CommandUtils.sendPluginMessage(sender, "&2Running &bLuckPerms v" + this.plugin.getVersion() + "&2."); + this.mainCommands.stream() .filter(Command::shouldDisplay) .filter(c -> c.isAuthorized(sender)) .forEach(c -> { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/CommandPermission.java b/common/src/main/java/me/lucko/luckperms/common/commands/CommandPermission.java index 92f2dbc72..2d55fad5c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/CommandPermission.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/CommandPermission.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.commands; -import lombok.AllArgsConstructor; -import lombok.Getter; - import me.lucko.luckperms.common.commands.sender.Sender; import static me.lucko.luckperms.common.commands.CommandPermission.Type.GROUP; @@ -173,7 +170,6 @@ public enum CommandPermission { private final String node; - @Getter private final Type type; CommandPermission(String node, Type type) { @@ -187,15 +183,17 @@ public enum CommandPermission { } public String getPermission() { - return node; + return this.node; } public boolean isAuthorized(Sender sender) { return sender.hasPermission(this); } - @Getter - @AllArgsConstructor + public Type getType() { + return this.type; + } + public enum Type { NONE(null), @@ -207,6 +205,13 @@ public enum CommandPermission { private final String tag; + Type(String tag) { + this.tag = tag; + } + + public String getTag() { + return this.tag; + } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/CommandResult.java b/common/src/main/java/me/lucko/luckperms/common/commands/CommandResult.java index 8a0464fc5..ad935589a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/CommandResult.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/CommandResult.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.commands; -import lombok.AllArgsConstructor; - -@AllArgsConstructor public enum CommandResult { SUCCESS(true), FAILURE(false), @@ -41,10 +38,14 @@ public enum CommandResult { return b ? SUCCESS : FAILURE; } - private boolean value; + private final boolean value; + + CommandResult(boolean value) { + this.value = value; + } public boolean asBoolean() { - return value; + return this.value; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/Command.java b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/Command.java index 12e620239..a154dc802 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/Command.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/Command.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.commands.abstraction; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.common.commands.Arg; @@ -50,13 +48,11 @@ import java.util.function.Predicate; */ public abstract class Command { - @Getter private final LocalizedSpec spec; /** * The name of the command. Should be properly capitalised. */ - @Getter private final String name; /** @@ -67,7 +63,6 @@ public abstract class Command { /** * A predicate used for testing the size of the arguments list passed to this command */ - @Getter private final Predicate argumentCheck; /** @@ -97,6 +92,18 @@ public abstract class Command { return Collections.emptyList(); } + public LocalizedSpec getSpec() { + return this.spec; + } + + public String getName() { + return this.name; + } + + public Predicate getArgumentCheck() { + return this.argumentCheck; + } + /** * Sends a brief command usage message to the Sender. * If this command has child commands, the children are listed. Otherwise, a basic usage message is sent. @@ -126,7 +133,7 @@ public abstract class Command { * @return true if the sender has permission to use this command */ public boolean isAuthorized(Sender sender) { - return permission == null || permission.isAuthorized(sender); + return this.permission == null || this.permission.isAuthorized(sender); } /** @@ -139,7 +146,7 @@ public abstract class Command { } public String getDescription() { - return spec.description(); + return this.spec.description(); } /** @@ -148,20 +155,19 @@ public abstract class Command { * @return the usage of this command. */ public String getUsage() { - String usage = spec.usage(); + String usage = this.spec.usage(); return usage == null ? "" : usage; } public Optional getPermission() { - return Optional.ofNullable(permission); + return Optional.ofNullable(this.permission); } public Optional> getArgs() { - return Optional.ofNullable(spec.args()); + return Optional.ofNullable(this.spec.args()); } public Optional>> getChildren() { - return Optional.ofNullable(children); + return Optional.ofNullable(this.children); } - } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/MainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/MainCommand.java index e1811096b..a8b9fe090 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/MainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/MainCommand.java @@ -54,14 +54,14 @@ public abstract class MainCommand extends Command { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Void v, List args, String label) throws CommandException { - if (args.size() < minArgs) { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Void v, List args, String label) { + if (args.size() < this.minArgs) { sendUsage(sender, label); return CommandResult.INVALID_ARGS; } Optional> o = getChildren().get().stream() - .filter(s -> s.getName().equalsIgnoreCase(args.get(minArgs - 1))) + .filter(s -> s.getName().equalsIgnoreCase(args.get(this.minArgs - 1))) .limit(1) .findAny(); @@ -77,8 +77,8 @@ public abstract class MainCommand extends Command { } List strippedArgs = new ArrayList<>(); - if (args.size() > minArgs) { - strippedArgs.addAll(args.subList(minArgs, args.size())); + if (args.size() > this.minArgs) { + strippedArgs.addAll(args.subList(this.minArgs, args.size())); } if (sub.getArgumentCheck().test(strippedArgs.size())) { @@ -169,7 +169,7 @@ public abstract class MainCommand extends Command { .filter(s -> s.isAuthorized(sender)) .collect(Collectors.toList()); - if (subs.size() > 0) { + if (!subs.isEmpty()) { CommandUtils.sendPluginMessage(sender, "&b" + getName() + " Sub Commands: &7(" + String.format(getUsage(), label) + " ...)"); for (Command s : subs) { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedMainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedMainCommand.java index 467bee666..7ee10ec1f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedMainCommand.java @@ -63,13 +63,13 @@ public class SharedMainCommand extends SubCommand } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, T t, List args, String label) throws CommandException { - if (args.size() == 0) { - sendUsageDetailed(sender, user, label); + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, T t, List args, String label) { + if (args.isEmpty()) { + sendUsageDetailed(sender, this.user, label); return CommandResult.INVALID_ARGS; } - Optional o = secondaryCommands.stream() + Optional o = this.secondaryCommands.stream() .filter(s -> s.getName().equalsIgnoreCase(args.get(0))) .limit(1) .findAny(); @@ -80,7 +80,7 @@ public class SharedMainCommand extends SubCommand } final SharedSubCommand sub = o.get(); - if (!sub.isAuthorized(sender, user)) { + if (!sub.isAuthorized(sender, this.user)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; } @@ -97,7 +97,7 @@ public class SharedMainCommand extends SubCommand CommandResult result; try { - result = sub.execute(plugin, sender, t, strippedArgs, label, user ? sub.getUserPermission() : sub.getGroupPermission()); + result = sub.execute(plugin, sender, t, strippedArgs, label, this.user ? sub.getUserPermission() : sub.getGroupPermission()); } catch (CommandException e) { result = handleException(e, sender, sub); } @@ -106,8 +106,8 @@ public class SharedMainCommand extends SubCommand @Override public List tabComplete(LuckPermsPlugin plugin, Sender sender, List args) { - final List subs = secondaryCommands.stream() - .filter(s -> s.isAuthorized(sender, user)) + final List subs = this.secondaryCommands.stream() + .filter(s -> s.isAuthorized(sender, this.user)) .collect(Collectors.toList()); if (args.size() <= 1) { @@ -134,15 +134,15 @@ public class SharedMainCommand extends SubCommand @Override public boolean isAuthorized(Sender sender) { - return secondaryCommands.stream().anyMatch(sc -> sc.isAuthorized(sender, user)); + return this.secondaryCommands.stream().anyMatch(sc -> sc.isAuthorized(sender, this.user)); } private void sendUsageDetailed(Sender sender, boolean user, String label) { - List subs = secondaryCommands.stream() + List subs = this.secondaryCommands.stream() .filter(s -> s.isAuthorized(sender, user)) .collect(Collectors.toList()); - if (subs.size() > 0) { + if (!subs.isEmpty()) { if (user) { CommandUtils.sendPluginMessage(sender, "&b" + getName() + " Sub Commands: &7(" + String.format("/%s user " + getName().toLowerCase() + " ...)", label)); } else { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedSubCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedSubCommand.java index ac04f1d2b..3ed1f2a83 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedSubCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SharedSubCommand.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.commands.abstraction; -import lombok.Getter; - import me.lucko.luckperms.common.commands.Arg; import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; @@ -47,7 +45,6 @@ import java.util.function.Predicate; * A sub command which can be be applied to both groups and users. * This doesn't extend the other Command or SubCommand classes to avoid generics hell. */ -@Getter public abstract class SharedSubCommand { private final LocalizedSpec spec; @@ -82,6 +79,26 @@ public abstract class SharedSubCommand { return Collections.emptyList(); } + public LocalizedSpec getSpec() { + return this.spec; + } + + public String getName() { + return this.name; + } + + public CommandPermission getUserPermission() { + return this.userPermission; + } + + public CommandPermission getGroupPermission() { + return this.groupPermission; + } + + public Predicate getArgumentCheck() { + return this.argumentCheck; + } + public void sendUsage(Sender sender) { StringBuilder sb = new StringBuilder(); if (getArgs() != null) { @@ -106,15 +123,15 @@ public abstract class SharedSubCommand { } public boolean isAuthorized(Sender sender, boolean user) { - return user ? userPermission.isAuthorized(sender) : groupPermission.isAuthorized(sender); + return user ? this.userPermission.isAuthorized(sender) : this.groupPermission.isAuthorized(sender); } public String getDescription() { - return spec.description(); + return this.spec.description(); } public List getArgs() { - return spec.args(); + return this.spec.args(); } public static void save(PermissionHolder holder, Sender sender, LuckPermsPlugin plugin) { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SubCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SubCommand.java index 3b9b95b74..0701961f8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SubCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/abstraction/SubCommand.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.commands.abstraction; -import lombok.Getter; - import com.google.common.base.Splitter; import me.lucko.luckperms.common.commands.Arg; @@ -56,7 +54,6 @@ import java.util.stream.Collectors; /** * Abstract SubCommand class */ -@Getter public abstract class SubCommand extends Command { public SubCommand(LocalizedSpec spec, String name, CommandPermission permission, Predicate argumentCheck) { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddChatMeta.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddChatMeta.java index c33f3bb9a..ffc85c10d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddChatMeta.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddChatMeta.java @@ -82,24 +82,24 @@ public class MetaAddChatMeta extends SharedSubCommand { return CommandResult.NO_PERMISSION; } - DataMutateResult result = holder.setPermission(NodeFactory.buildChatMetaNode(type, priority, meta).withExtraContext(context).build()); + DataMutateResult result = holder.setPermission(NodeFactory.buildChatMetaNode(this.type, priority, meta).withExtraContext(context).build()); if (result.asBoolean()) { - TextComponent.Builder builder = TextUtils.fromLegacy(Message.ADD_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); + TextComponent.Builder builder = TextUtils.fromLegacy(Message.ADD_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); HoverEvent event = new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextUtils.fromLegacy( - "¥3Raw " + type.name().toLowerCase() + ": ¥r" + meta, + "¥3Raw " + this.type.name().toLowerCase() + ": ¥r" + meta, '¥' )); builder.applyDeep(c -> c.hoverEvent(event)); sender.sendMessage(builder.build()); ExtendedLogEntry.build().actor(sender).acted(holder) - .action("meta" , "add" + type.name().toLowerCase(), priority, meta, context) + .action("meta" , "add" + this.type.name().toLowerCase(), priority, meta, context) .build().submit(plugin, sender); save(holder, sender, plugin); return CommandResult.SUCCESS; } else { - Message.ALREADY_HAS_CHAT_META.send(sender, holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); + Message.ALREADY_HAS_CHAT_META.send(sender, holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); return CommandResult.STATE_ERROR; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddTempChatMeta.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddTempChatMeta.java index ac731546b..fe40735e4 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddTempChatMeta.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaAddTempChatMeta.java @@ -89,27 +89,27 @@ public class MetaAddTempChatMeta extends SharedSubCommand { return CommandResult.NO_PERMISSION; } - Map.Entry ret = holder.setPermission(NodeFactory.buildChatMetaNode(type, priority, meta).setExpiry(duration).withExtraContext(context).build(), modifier); + Map.Entry ret = holder.setPermission(NodeFactory.buildChatMetaNode(this.type, priority, meta).setExpiry(duration).withExtraContext(context).build(), modifier); if (ret.getKey().asBoolean()) { duration = ret.getValue().getExpiryUnixTime(); - TextComponent.Builder builder = TextUtils.fromLegacy(Message.ADD_TEMP_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, DateUtil.formatDateDiff(duration), CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); + TextComponent.Builder builder = TextUtils.fromLegacy(Message.ADD_TEMP_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, DateUtil.formatDateDiff(duration), CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); HoverEvent event = new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextUtils.fromLegacy( - "¥3Raw " + type.name().toLowerCase() + ": ¥r" + meta, + "¥3Raw " + this.type.name().toLowerCase() + ": ¥r" + meta, '¥' )); builder.applyDeep(c -> c.hoverEvent(event)); sender.sendMessage(builder.build()); ExtendedLogEntry.build().actor(sender).acted(holder) - .action("meta" , "addtemp" + type.name().toLowerCase(), priority, meta, duration, context) + .action("meta" , "addtemp" + this.type.name().toLowerCase(), priority, meta, duration, context) .build().submit(plugin, sender); save(holder, sender, plugin); return CommandResult.SUCCESS; } else { - Message.ALREADY_HAS_TEMP_CHAT_META.send(sender, holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); + Message.ALREADY_HAS_TEMP_CHAT_META.send(sender, holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); return CommandResult.STATE_ERROR; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaClear.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaClear.java index 65c2012a3..4924c0f88 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaClear.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaClear.java @@ -59,7 +59,7 @@ public class MetaClear extends SharedSubCommand { } MetaType type = null; - if (args.size() > 0) { + if (!args.isEmpty()) { String typeId = args.get(0).toLowerCase(); if (typeId.equals("any") || typeId.equals("all") || typeId.equals("*")) { type = MetaType.ANY; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaInfo.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaInfo.java index 46ae06f06..0b597fad9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaInfo.java @@ -30,7 +30,6 @@ import com.google.common.collect.Maps; import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandManager; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; @@ -71,7 +70,7 @@ public class MetaInfo extends SharedSubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, PermissionHolder holder, List args, String label, CommandPermission permission) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, PermissionHolder holder, List args, String label, CommandPermission permission) { if (ArgumentPermissions.checkViewPerms(plugin, sender, permission, holder)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveChatMeta.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveChatMeta.java index b52e13391..6a43bbfa8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveChatMeta.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveChatMeta.java @@ -85,40 +85,40 @@ public class MetaRemoveChatMeta extends SharedSubCommand { // Handle bulk removal if (meta.equalsIgnoreCase("null") || meta.equals("*")) { holder.removeIf(n -> - type.matches(n) && - type.getEntry(n).getKey() == priority && + this.type.matches(n) && + this.type.getEntry(n).getKey() == priority && !n.isTemporary() && n.getFullContexts().makeImmutable().equals(context.makeImmutable()) ); - Message.BULK_REMOVE_CHATMETA_SUCCESS.send(sender, holder.getFriendlyName(), type.name().toLowerCase(), priority, CommandUtils.contextSetToString(context)); + Message.BULK_REMOVE_CHATMETA_SUCCESS.send(sender, holder.getFriendlyName(), this.type.name().toLowerCase(), priority, CommandUtils.contextSetToString(context)); ExtendedLogEntry.build().actor(sender).acted(holder) - .action("meta" , "remove" + type.name().toLowerCase(), priority, "*", context) + .action("meta" , "remove" + this.type.name().toLowerCase(), priority, "*", context) .build().submit(plugin, sender); save(holder, sender, plugin); return CommandResult.SUCCESS; } - DataMutateResult result = holder.unsetPermission(NodeFactory.buildChatMetaNode(type, priority, meta).withExtraContext(context).build()); + DataMutateResult result = holder.unsetPermission(NodeFactory.buildChatMetaNode(this.type, priority, meta).withExtraContext(context).build()); if (result.asBoolean()) { - TextComponent.Builder builder = TextUtils.fromLegacy(Message.REMOVE_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); + TextComponent.Builder builder = TextUtils.fromLegacy(Message.REMOVE_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); HoverEvent event = new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextUtils.fromLegacy( - "¥3Raw " + type.name().toLowerCase() + ": ¥r" + meta, + "¥3Raw " + this.type.name().toLowerCase() + ": ¥r" + meta, '¥' )); builder.applyDeep(c -> c.hoverEvent(event)); sender.sendMessage(builder.build()); ExtendedLogEntry.build().actor(sender).acted(holder) - .action("meta" , "remove" + type.name().toLowerCase(), priority, meta, context) + .action("meta" , "remove" + this.type.name().toLowerCase(), priority, meta, context) .build().submit(plugin, sender); save(holder, sender, plugin); return CommandResult.SUCCESS; } else { - Message.DOES_NOT_HAVE_CHAT_META.send(sender, holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); + Message.DOES_NOT_HAVE_CHAT_META.send(sender, holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); return CommandResult.STATE_ERROR; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveTempChatMeta.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveTempChatMeta.java index 86b9b9043..1b6cc04ba 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveTempChatMeta.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/meta/MetaRemoveTempChatMeta.java @@ -85,40 +85,40 @@ public class MetaRemoveTempChatMeta extends SharedSubCommand { // Handle bulk removal if (meta.equalsIgnoreCase("null") || meta.equals("*")) { holder.removeIf(n -> - type.matches(n) && - type.getEntry(n).getKey() == priority && + this.type.matches(n) && + this.type.getEntry(n).getKey() == priority && !n.isPermanent() && n.getFullContexts().makeImmutable().equals(context.makeImmutable()) ); - Message.BULK_REMOVE_TEMP_CHATMETA_SUCCESS.send(sender, holder.getFriendlyName(), type.name().toLowerCase(), priority, CommandUtils.contextSetToString(context)); + Message.BULK_REMOVE_TEMP_CHATMETA_SUCCESS.send(sender, holder.getFriendlyName(), this.type.name().toLowerCase(), priority, CommandUtils.contextSetToString(context)); ExtendedLogEntry.build().actor(sender).acted(holder) - .action("meta" , "removetemp" + type.name().toLowerCase(), priority, "*", context) + .action("meta" , "removetemp" + this.type.name().toLowerCase(), priority, "*", context) .build().submit(plugin, sender); save(holder, sender, plugin); return CommandResult.SUCCESS; } - DataMutateResult result = holder.unsetPermission(NodeFactory.buildChatMetaNode(type, priority, meta).setExpiry(10L).withExtraContext(context).build()); + DataMutateResult result = holder.unsetPermission(NodeFactory.buildChatMetaNode(this.type, priority, meta).setExpiry(10L).withExtraContext(context).build()); if (result.asBoolean()) { - TextComponent.Builder builder = TextUtils.fromLegacy(Message.REMOVE_TEMP_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); + TextComponent.Builder builder = TextUtils.fromLegacy(Message.REMOVE_TEMP_CHATMETA_SUCCESS.asString(plugin.getLocaleManager(), holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)), CommandManager.SECTION_CHAR).toBuilder(); HoverEvent event = new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextUtils.fromLegacy( - "¥3Raw " + type.name().toLowerCase() + ": ¥r" + meta, + "¥3Raw " + this.type.name().toLowerCase() + ": ¥r" + meta, '¥' )); builder.applyDeep(c -> c.hoverEvent(event)); sender.sendMessage(builder.build()); ExtendedLogEntry.build().actor(sender).acted(holder) - .action("meta" , "removetemp" + type.name().toLowerCase(), priority, meta, context) + .action("meta" , "removetemp" + this.type.name().toLowerCase(), priority, meta, context) .build().submit(plugin, sender); save(holder, sender, plugin); return CommandResult.SUCCESS; } else { - Message.DOES_NOT_HAVE_TEMP_CHAT_META.send(sender, holder.getFriendlyName(), type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); + Message.DOES_NOT_HAVE_TEMP_CHAT_META.send(sender, holder.getFriendlyName(), this.type.name().toLowerCase(), meta, priority, CommandUtils.contextSetToString(context)); return CommandResult.STATE_ERROR; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderEditor.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderEditor.java index e14366904..d714f4db2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderEditor.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderEditor.java @@ -31,7 +31,6 @@ import com.google.gson.JsonObject; import com.google.gson.JsonPrimitive; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -61,7 +60,7 @@ public class HolderEditor extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, T holder, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, T holder, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), holder)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderShowTracks.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderShowTracks.java index 3412ba45a..d0c47c03d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderShowTracks.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/other/HolderShowTracks.java @@ -29,7 +29,6 @@ import com.google.common.collect.Maps; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -55,7 +54,7 @@ public class HolderShowTracks extends SubCommand } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, T holder, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, T holder, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), holder)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentInfo.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentInfo.java index 9ffbc395c..634192aab 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentInfo.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.common.commands.impl.generic.parent; import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandManager; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; @@ -67,7 +66,7 @@ public class ParentInfo extends SharedSubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, PermissionHolder holder, List args, String label, CommandPermission permission) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, PermissionHolder holder, List args, String label, CommandPermission permission) { if (ArgumentPermissions.checkViewPerms(plugin, sender, permission, holder)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentSetTrack.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentSetTrack.java index ec7df9545..25afa2fd3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentSetTrack.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/parent/ParentSetTrack.java @@ -140,7 +140,7 @@ public class ParentSetTrack extends SharedSubCommand { @Override public List onTabComplete(LuckPermsPlugin plugin, Sender sender, List args) { - if (args.size() == 0 || args.size() == 1) { + if (args.isEmpty() || args.size() == 1) { return getTrackTabComplete(args, plugin); } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/permission/PermissionInfo.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/permission/PermissionInfo.java index f9d04eeef..ebed8fba5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/permission/PermissionInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/generic/permission/PermissionInfo.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.common.commands.impl.generic.permission; import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandManager; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; @@ -67,7 +66,7 @@ public class PermissionInfo extends SharedSubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, PermissionHolder holder, List args, String label, CommandPermission permission) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, PermissionHolder holder, List args, String label, CommandPermission permission) { if (ArgumentPermissions.checkViewPerms(plugin, sender, permission, holder)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/CreateGroup.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/CreateGroup.java index eac8aed4a..4308d8639 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/CreateGroup.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/CreateGroup.java @@ -48,7 +48,7 @@ public class CreateGroup extends SingleCommand { @Override public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() == 0) { + if (args.isEmpty()) { sendUsage(sender, label); return CommandResult.INVALID_ARGS; } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/DeleteGroup.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/DeleteGroup.java index 3104dc647..4109240ad 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/DeleteGroup.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/DeleteGroup.java @@ -50,7 +50,7 @@ public class DeleteGroup extends SingleCommand { @Override public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() == 0) { + if (args.isEmpty()) { sendUsage(sender, label); return CommandResult.INVALID_ARGS; } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupClone.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupClone.java index feffab3d1..a3ca22848 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupClone.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupClone.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.common.commands.impl.group; import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -49,7 +48,7 @@ public class GroupClone extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), group)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupInfo.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupInfo.java index 22d04c925..161538e22 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupInfo.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.group; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -51,7 +50,7 @@ public class GroupInfo extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), group)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupListMembers.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupListMembers.java index 7e73eff45..e0f4cabc2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupListMembers.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupListMembers.java @@ -32,7 +32,6 @@ import com.google.common.collect.Maps; import me.lucko.luckperms.api.HeldPermission; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandManager; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; @@ -70,7 +69,7 @@ public class GroupListMembers extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), group)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupMainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupMainCommand.java index 8cdfce5a5..2e7e9a616 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupMainCommand.java @@ -106,7 +106,7 @@ public class GroupMainCommand extends MainCommand { @Override protected ReentrantLock getLockForTarget(String target) { - return locks.get(target); + return this.locks.get(target); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupRename.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupRename.java index d15890410..b7cfb7898 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupRename.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupRename.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.common.commands.impl.group; import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.api.event.cause.DeletionCause; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -49,7 +48,7 @@ public class GroupRename extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { String newGroupName = args.get(0).toLowerCase(); if (!DataConstraints.GROUP_NAME_TEST.test(newGroupName)) { Message.GROUP_INVALID_ENTRY.send(sender, newGroupName); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupSetDisplayName.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupSetDisplayName.java index 42c68d842..aff179cec 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupSetDisplayName.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/group/GroupSetDisplayName.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.group; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -49,7 +48,7 @@ public class GroupSetDisplayName extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Group group, List args, String label) { if (ArgumentPermissions.checkModifyPerms(plugin, sender, getPermission().get(), group)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogGroupHistory.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogGroupHistory.java index aaaaa5762..c0bc9d810 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogGroupHistory.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogGroupHistory.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.log; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.actionlog.Log; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -52,7 +51,7 @@ public class LogGroupHistory extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) { String group = args.get(0).toLowerCase(); int page = Integer.MIN_VALUE; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogMainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogMainCommand.java index 99d421cae..2e5e6e731 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogMainCommand.java @@ -59,7 +59,7 @@ public class LogMainCommand extends MainCommand { @Override protected ReentrantLock getLockForTarget(Object target) { - return lock; // all commands target the same log, so we share a lock between all "targets" + return this.lock; // all commands target the same log, so we share a lock between all "targets" } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogNotify.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogNotify.java index 7b9d6f460..219d54d73 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogNotify.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogNotify.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.log; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.actionlog.Log; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -82,14 +81,14 @@ public class LogNotify extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) { if (sender.isConsole() || sender.isImport()) { Message.LOG_NOTIFY_CONSOLE.send(sender); return CommandResult.SUCCESS; } final UUID uuid = sender.getUuid(); - if (args.size() == 0) { + if (args.isEmpty()) { if (isIgnoring(plugin, uuid)) { // toggle on setIgnoring(plugin, uuid, false); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogRecent.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogRecent.java index c78b545a8..a7c4188b6 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogRecent.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogRecent.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.log; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.actionlog.Log; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -55,8 +54,8 @@ public class LogRecent extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) throws CommandException { - if (args.size() == 0) { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) { + if (args.isEmpty()) { // No page or user return showLog(log.getRecentMaxPages(ENTRIES_PER_PAGE), null, sender, log); } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogSearch.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogSearch.java index 18de1c85d..e95253067 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogSearch.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogSearch.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.log; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.actionlog.Log; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -52,7 +51,7 @@ public class LogSearch extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) { int page = Integer.MIN_VALUE; if (args.size() > 1) { try { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogTrackHistory.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogTrackHistory.java index bea135c0b..ab9d7ce3d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogTrackHistory.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogTrackHistory.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.log; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.actionlog.Log; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -52,7 +51,7 @@ public class LogTrackHistory extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) { String track = args.get(0).toLowerCase(); int page = Integer.MIN_VALUE; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogUserHistory.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogUserHistory.java index ac8eb6950..8bef54816 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogUserHistory.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/log/LogUserHistory.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.log; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.actionlog.Log; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -55,7 +54,7 @@ public class LogUserHistory extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Log log, List args, String label) { String target = args.get(0); int page = Integer.MIN_VALUE; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationMainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationMainCommand.java index 4ac0985f6..198758b3d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationMainCommand.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.migration; import com.google.common.collect.ImmutableBiMap; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.Command; @@ -72,22 +71,22 @@ public class MigrationMainCommand extends MainCommand { @Override public synchronized Optional>> getChildren() { - if (commands == null) { - commands = getAvailableCommands(getSpec().getLocaleManager()); + if (this.commands == null) { + this.commands = getAvailableCommands(getSpec().getLocaleManager()); // Add dummy command to show in the list. - if (commands.isEmpty()) { - display = false; - commands.add(new SubCommand(CommandSpec.MIGRATION_COMMAND.spec(getSpec().getLocaleManager()), "No available plugins to migrate from", CommandPermission.MIGRATION, Predicates.alwaysFalse()) { + if (this.commands.isEmpty()) { + this.display = false; + this.commands.add(new SubCommand(CommandSpec.MIGRATION_COMMAND.spec(getSpec().getLocaleManager()), "No available plugins to migrate from", CommandPermission.MIGRATION, Predicates.alwaysFalse()) { @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { return CommandResult.SUCCESS; } }); } } - return Optional.of(commands); + return Optional.of(this.commands); } @Override @@ -98,7 +97,7 @@ public class MigrationMainCommand extends MainCommand { @Override public boolean shouldDisplay() { getChildren(); - return display; + return this.display; } @SuppressWarnings("unchecked") @@ -117,7 +116,7 @@ public class MigrationMainCommand extends MainCommand { @Override protected ReentrantLock getLockForTarget(Object target) { - return lock; // share a lock between all migration commands + return this.lock; // share a lock between all migration commands } /* Dummy */ diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationUtils.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationUtils.java index f005786b8..0eea849bd 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationUtils.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/migration/MigrationUtils.java @@ -25,14 +25,11 @@ package me.lucko.luckperms.common.commands.impl.migration; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.node.NodeFactory; -@UtilityClass -public class MigrationUtils { +public final class MigrationUtils { public static Node.Builder parseNode(String permission, boolean value) { if (permission.startsWith("-") || permission.startsWith("!")) { @@ -63,4 +60,6 @@ public class MigrationUtils { return string.trim().replace(':', '-').replace(' ', '-').replace('.', '-').toLowerCase(); } + private MigrationUtils() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ApplyEditsCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ApplyEditsCommand.java index 389bd4389..6f2eaf448 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ApplyEditsCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ApplyEditsCommand.java @@ -31,7 +31,6 @@ import com.google.gson.JsonObject; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SharedSubCommand; @@ -60,7 +59,7 @@ public class ApplyEditsCommand extends SingleCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { String code = args.get(0); String who = args.size() == 2 ? args.get(1) : null; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/BulkUpdateCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/BulkUpdateCommand.java index adad0375f..12ca8bbcf 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/BulkUpdateCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/BulkUpdateCommand.java @@ -64,7 +64,7 @@ public class BulkUpdateCommand extends SingleCommand { if (args.size() == 2 && args.get(0).equalsIgnoreCase("confirm")) { String id = args.get(1); - BulkUpdate operation = pendingOperations.asMap().remove(id); + BulkUpdate operation = this.pendingOperations.asMap().remove(id); if (operation == null) { Message.BULK_UPDATE_UNKNOWN_ID.send(sender, id); @@ -147,7 +147,7 @@ public class BulkUpdateCommand extends SingleCommand { BulkUpdate bulkUpdate = bulkUpdateBuilder.build(); - pendingOperations.put(id, bulkUpdate); + this.pendingOperations.put(id, bulkUpdate); Message.BULK_UPDATE_QUEUED.send(sender, bulkUpdate.buildAsSql().replace("{table}", bulkUpdate.getDataType().getName())); Message.BULK_UPDATE_CONFIRM.send(sender, label, id); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/CheckCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/CheckCommand.java index 43f50c6ca..0157e37fb 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/CheckCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/CheckCommand.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.common.commands.impl.misc; import me.lucko.luckperms.api.Tristate; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SingleCommand; @@ -51,7 +50,7 @@ public class CheckCommand extends SingleCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { String target = args.get(0); String permission = args.get(1); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ExportCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ExportCommand.java index c81b469a9..b576fbeb6 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ExportCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ExportCommand.java @@ -52,7 +52,7 @@ public class ExportCommand extends SingleCommand { @Override public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (running.get()) { + if (this.running.get()) { Message.EXPORT_ALREADY_RUNNING.send(sender); return CommandResult.STATE_ERROR; } @@ -78,7 +78,7 @@ public class ExportCommand extends SingleCommand { return CommandResult.FAILURE; } - if (!running.compareAndSet(false, true)) { + if (!this.running.compareAndSet(false, true)) { Message.EXPORT_ALREADY_RUNNING.send(sender); return CommandResult.STATE_ERROR; } @@ -90,7 +90,7 @@ public class ExportCommand extends SingleCommand { try { exporter.run(); } finally { - running.set(false); + this.running.set(false); } }); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ImportCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ImportCommand.java index 16f49019e..c4533f37c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ImportCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ImportCommand.java @@ -53,7 +53,7 @@ public class ImportCommand extends SingleCommand { @Override public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (running.get()) { + if (this.running.get()) { Message.IMPORT_ALREADY_RUNNING.send(sender); return CommandResult.STATE_ERROR; } @@ -81,7 +81,7 @@ public class ImportCommand extends SingleCommand { return CommandResult.FAILURE; } - if (!running.compareAndSet(false, true)) { + if (!this.running.compareAndSet(false, true)) { Message.IMPORT_ALREADY_RUNNING.send(sender); return CommandResult.STATE_ERROR; } @@ -93,7 +93,7 @@ public class ImportCommand extends SingleCommand { try { importer.run(); } finally { - running.set(false); + this.running.set(false); } }); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ReloadConfigCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ReloadConfigCommand.java index 1a00d4737..622ede654 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ReloadConfigCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/ReloadConfigCommand.java @@ -25,7 +25,6 @@ package me.lucko.luckperms.common.commands.impl.misc; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SingleCommand; @@ -44,7 +43,7 @@ public class ReloadConfigCommand extends SingleCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { plugin.getConfiguration().reload(); Message.RELOAD_CONFIG_SUCCESS.send(sender); return CommandResult.SUCCESS; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/SearchCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/SearchCommand.java index 83ae95682..3ccda11f7 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/SearchCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/SearchCommand.java @@ -31,7 +31,6 @@ import com.google.common.collect.Maps; import me.lucko.luckperms.api.HeldPermission; import me.lucko.luckperms.api.Node; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandManager; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; @@ -69,7 +68,7 @@ public class SearchCommand extends SingleCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { String query = args.get(0); int page = ArgumentUtils.handleIntOrElse(1, args, 1); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/TreeCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/TreeCommand.java index 9f0995e6d..84661890a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/TreeCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/misc/TreeCommand.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.common.commands.impl.misc; import me.lucko.luckperms.common.caching.type.PermissionCache; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SingleCommand; @@ -57,12 +56,12 @@ public class TreeCommand extends SingleCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { String selection = "."; int maxLevel = 5; String player = null; - if (args.size() > 0) { + if (!args.isEmpty()) { selection = args.get(0); } if (args.size() > 1) { diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/CreateTrack.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/CreateTrack.java index 89e80ba23..be9a38223 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/CreateTrack.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/CreateTrack.java @@ -48,7 +48,7 @@ public class CreateTrack extends SingleCommand { @Override public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() == 0) { + if (args.isEmpty()) { sendUsage(sender, label); return CommandResult.INVALID_ARGS; } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/DeleteTrack.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/DeleteTrack.java index dd41dd52e..256564958 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/DeleteTrack.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/DeleteTrack.java @@ -49,7 +49,7 @@ public class DeleteTrack extends SingleCommand { @Override public CommandResult execute(LuckPermsPlugin plugin, Sender sender, List args, String label) { - if (args.size() == 0) { + if (args.isEmpty()) { sendUsage(sender, label); return CommandResult.INVALID_ARGS; } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackAppend.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackAppend.java index 141cd68d8..c1fc8c86b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackAppend.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackAppend.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.track; import me.lucko.luckperms.api.DataMutateResult; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -50,7 +49,7 @@ public class TrackAppend extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String groupName = args.get(0).toLowerCase(); if (!DataConstraints.GROUP_NAME_TEST.test(groupName)) { sendDetailedUsage(sender, label); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClear.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClear.java index e0c2672df..b6a1c4548 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClear.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClear.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.common.commands.impl.track; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -46,7 +45,7 @@ public class TrackClear extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { track.clearGroups(); Message.TRACK_CLEAR.send(sender, track.getName()); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClone.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClone.java index 476d0ce03..b8d322d8d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClone.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackClone.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.track; import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -48,7 +47,7 @@ public class TrackClone extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String newTrackName = args.get(0).toLowerCase(); if (!DataConstraints.TRACK_NAME_TEST.test(newTrackName)) { Message.TRACK_INVALID_ENTRY.send(sender, newTrackName); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInfo.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInfo.java index d75d7f5b0..b7493ca14 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInfo.java @@ -25,7 +25,6 @@ package me.lucko.luckperms.common.commands.impl.track; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -46,7 +45,7 @@ public class TrackInfo extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { Message.TRACK_INFO.send(sender, track.getName(), CommandUtils.listToArrowSep(track.getGroups())); return CommandResult.SUCCESS; } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInsert.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInsert.java index d1456e28d..43e016377 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInsert.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackInsert.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.track; import me.lucko.luckperms.api.DataMutateResult; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -50,7 +49,7 @@ public class TrackInsert extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String groupName = args.get(0).toLowerCase(); if (!DataConstraints.GROUP_NAME_TEST.test(groupName)) { sendDetailedUsage(sender, label); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackMainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackMainCommand.java index dc791be38..495a2a914 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackMainCommand.java @@ -89,7 +89,7 @@ public class TrackMainCommand extends MainCommand { @Override protected ReentrantLock getLockForTarget(String target) { - return locks.get(target); + return this.locks.get(target); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRemove.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRemove.java index cfce1d489..1468d8772 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRemove.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRemove.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.track; import me.lucko.luckperms.api.DataMutateResult; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -49,7 +48,7 @@ public class TrackRemove extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String groupName = args.get(0).toLowerCase(); if (!DataConstraints.GROUP_NAME_TEST.test(groupName)) { sendDetailedUsage(sender, label); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRename.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRename.java index ce1a8b569..7b6da201f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRename.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/track/TrackRename.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.common.commands.impl.track; import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.api.event.cause.DeletionCause; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -49,7 +48,7 @@ public class TrackRename extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Track track, List args, String label) { String newTrackName = args.get(0).toLowerCase(); if (!DataConstraints.TRACK_NAME_TEST.test(newTrackName)) { Message.TRACK_INVALID_ENTRY.send(sender, newTrackName); diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserClone.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserClone.java index 64a7f2416..022846c11 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserClone.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserClone.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.user; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -51,7 +50,7 @@ public class UserClone extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), user)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserInfo.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserInfo.java index 8910b1fa4..8342d95e5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserInfo.java @@ -29,7 +29,6 @@ import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.caching.MetaData; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -54,7 +53,7 @@ public class UserInfo extends SubCommand { @SuppressWarnings("unchecked") @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { if (ArgumentPermissions.checkViewPerms(plugin, sender, getPermission().get(), user)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserMainCommand.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserMainCommand.java index 0ddffb03b..780b99082 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserMainCommand.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserMainCommand.java @@ -139,7 +139,7 @@ public class UserMainCommand extends MainCommand { @Override protected ReentrantLock getLockForTarget(UserIdentifier target) { - return locks.get(target.getUuid()); + return this.locks.get(target.getUuid()); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserSwitchPrimaryGroup.java b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserSwitchPrimaryGroup.java index 519cb9ccd..f6275fb1b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserSwitchPrimaryGroup.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/impl/user/UserSwitchPrimaryGroup.java @@ -27,7 +27,6 @@ package me.lucko.luckperms.common.commands.impl.user; import me.lucko.luckperms.common.actionlog.ExtendedLogEntry; import me.lucko.luckperms.common.commands.ArgumentPermissions; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -50,7 +49,7 @@ public class UserSwitchPrimaryGroup extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, User user, List args, String label) { if (ArgumentPermissions.checkModifyPerms(plugin, sender, getPermission().get(), user)) { Message.COMMAND_NO_PERMISSION.send(sender); return CommandResult.NO_PERMISSION; diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/sender/AbstractSender.java b/common/src/main/java/me/lucko/luckperms/common/commands/sender/AbstractSender.java index 514fc654b..17ac2d69a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/sender/AbstractSender.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/sender/AbstractSender.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.commands.sender; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; - import com.google.common.base.Splitter; import me.lucko.luckperms.api.Tristate; @@ -46,17 +42,11 @@ import java.util.UUID; * * @param the command sender type */ -@Getter -@EqualsAndHashCode(of = "uuid") public final class AbstractSender implements Sender { private static final Splitter NEW_LINE_SPLITTER = Splitter.on("\n"); private final LuckPermsPlugin platform; - - @Getter(AccessLevel.NONE) private final SenderFactory factory; - - @Getter(AccessLevel.NONE) private final WeakReference reference; private final UUID uuid; @@ -70,19 +60,34 @@ public final class AbstractSender implements Sender { this.name = factory.getName(t); } + @Override + public LuckPermsPlugin getPlatform() { + return this.platform; + } + + @Override + public UUID getUuid() { + return this.uuid; + } + + @Override + public String getName() { + return this.name; + } + @Override public void sendMessage(String message) { - final T t = reference.get(); + final T t = this.reference.get(); if (t != null) { if (!isConsole()) { - factory.sendMessage(t, message); + this.factory.sendMessage(t, message); return; } // if it is console, split up the lines and send individually. for (String line : NEW_LINE_SPLITTER.split(message)) { - factory.sendMessage(t, line); + this.factory.sendMessage(t, line); } } } @@ -95,17 +100,17 @@ public final class AbstractSender implements Sender { return; } - final T t = reference.get(); + final T t = this.reference.get(); if (t != null) { - factory.sendMessage(t, message); + this.factory.sendMessage(t, message); } } @Override public Tristate getPermissionValue(String permission) { - T t = reference.get(); + T t = this.reference.get(); if (t != null) { - return factory.getPermissionValue(t, permission); + return this.factory.getPermissionValue(t, permission); } return isConsole() ? Tristate.TRUE : Tristate.UNDEFINED; @@ -113,9 +118,9 @@ public final class AbstractSender implements Sender { @Override public boolean hasPermission(String permission) { - T t = reference.get(); + T t = this.reference.get(); if (t != null) { - if (factory.hasPermission(t, permission)) { + if (this.factory.hasPermission(t, permission)) { return true; } } @@ -125,11 +130,24 @@ public final class AbstractSender implements Sender { @Override public boolean isValid() { - return reference.get() != null; + return this.reference.get() != null; } @Override public Optional getHandle() { - return Optional.ofNullable(reference.get()); + return Optional.ofNullable(this.reference.get()); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof AbstractSender)) return false; + final AbstractSender that = (AbstractSender) o; + return this.getUuid().equals(that.getUuid()); + } + + @Override + public int hashCode() { + return this.uuid.hashCode(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/sender/SenderFactory.java b/common/src/main/java/me/lucko/luckperms/common/commands/sender/SenderFactory.java index 5b8a95f9b..4f4b834cd 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/sender/SenderFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/sender/SenderFactory.java @@ -25,16 +25,12 @@ package me.lucko.luckperms.common.commands.sender; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import net.kyori.text.Component; +import java.util.Objects; import java.util.UUID; /** @@ -42,12 +38,18 @@ import java.util.UUID; * * @param the command sender type */ -@RequiredArgsConstructor public abstract class SenderFactory { - @Getter(AccessLevel.PROTECTED) private final LuckPermsPlugin plugin; + public SenderFactory(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + protected LuckPermsPlugin getPlugin() { + return this.plugin; + } + protected abstract UUID getUuid(T t); protected abstract String getName(T t); @@ -60,7 +62,8 @@ public abstract class SenderFactory { protected abstract boolean hasPermission(T t, String node); - public final Sender wrap(@NonNull T sender) { - return new AbstractSender<>(plugin, this, sender); + public final Sender wrap(T sender) { + Objects.requireNonNull(sender, "sender"); + return new AbstractSender<>(this.plugin, this, sender); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/utils/ArgumentUtils.java b/common/src/main/java/me/lucko/luckperms/common/commands/utils/ArgumentUtils.java index 36e330d97..9dc037d5c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/utils/ArgumentUtils.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/utils/ArgumentUtils.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.commands.utils; -import lombok.AllArgsConstructor; -import lombok.Getter; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.api.context.MutableContextSet; @@ -84,7 +81,7 @@ public class ArgumentUtils { return groupName; } - public static boolean handleBoolean(int index, List args) throws ArgumentException { + public static boolean handleBoolean(int index, List args) { if (index < args.size()) { String bool = args.get(index); if (bool.equalsIgnoreCase("true") || bool.equalsIgnoreCase("false")) { @@ -239,16 +236,28 @@ public class ArgumentUtils { public static class InvalidServerWorldException extends ArgumentException {} public static class PastDateException extends ArgumentException {} - @Getter - @AllArgsConstructor public static class InvalidDateException extends ArgumentException { private final String invalidDate; + + public InvalidDateException(String invalidDate) { + this.invalidDate = invalidDate; + } + + public String getInvalidDate() { + return this.invalidDate; + } } - @Getter - @AllArgsConstructor public static class InvalidPriorityException extends ArgumentException { private final String invalidPriority; + + public InvalidPriorityException(String invalidPriority) { + this.invalidPriority = invalidPriority; + } + + public String getInvalidPriority() { + return this.invalidPriority; + } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/utils/CommandUtils.java b/common/src/main/java/me/lucko/luckperms/common/commands/utils/CommandUtils.java index 8fd460b97..2c840909b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/utils/CommandUtils.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/utils/CommandUtils.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.commands.utils; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.Tristate; @@ -43,8 +41,7 @@ import java.util.UUID; import java.util.function.Supplier; import java.util.regex.Pattern; -@UtilityClass -public class CommandUtils { +public final class CommandUtils { private static final Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)" + String.valueOf('§') + "[0-9A-FK-OR]"); /** @@ -246,4 +243,7 @@ public class CommandUtils { return sb.delete(sb.length() - Message.CONTEXT_PAIR_SEP.asString(null).length(), sb.length()).toString(); } + + private CommandUtils() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/commands/utils/SortMode.java b/common/src/main/java/me/lucko/luckperms/common/commands/utils/SortMode.java index f8eb82d82..2e036ec5f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/commands/utils/SortMode.java +++ b/common/src/main/java/me/lucko/luckperms/common/commands/utils/SortMode.java @@ -25,13 +25,8 @@ package me.lucko.luckperms.common.commands.utils; -import lombok.AllArgsConstructor; -import lombok.Getter; - import java.util.List; -@Getter -@AllArgsConstructor public class SortMode { public static SortMode determine(List args) { @@ -62,4 +57,17 @@ public class SortMode { private final SortType type; private final boolean ascending; + + public SortMode(SortType type, boolean ascending) { + this.type = type; + this.ascending = ascending; + } + + public SortType getType() { + return this.type; + } + + public boolean isAscending() { + return this.ascending; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java b/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java index 1e101c8b7..5a581a9f3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/AbstractConfiguration.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.config; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.github.benmanes.caffeine.cache.CacheLoader; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; @@ -42,16 +38,15 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; +import javax.annotation.Nonnull; + /** * An abstract implementation of {@link LuckPermsConfiguration}, backed by a cache. */ -@Getter -@RequiredArgsConstructor public class AbstractConfiguration implements LuckPermsConfiguration, CacheLoader, Optional> { // the loading cache for config keys --> their value // the value is wrapped in an optional as null values don't get cached. - @Getter(AccessLevel.NONE) private final LoadingCache, Optional> cache = Caffeine.newBuilder().build(this); // the plugin instance @@ -63,10 +58,34 @@ public class AbstractConfiguration implements LuckPermsConfiguration, CacheLoade // the contextsfile handler private final ContextsFile contextsFile = new ContextsFile(this); + public AbstractConfiguration(LuckPermsPlugin plugin, ConfigurationAdapter adapter) { + this.plugin = plugin; + this.adapter = adapter; + } + + public ConfigurationAdapter getAdapter() { + return this.adapter; + } + + @Override + public LuckPermsPlugin getPlugin() { + return this.plugin; + } + + @Override + public ApiConfiguration getDelegate() { + return this.delegate; + } + + @Override + public ContextsFile getContextsFile() { + return this.contextsFile; + } + @SuppressWarnings("unchecked") @Override public T get(ConfigKey key) { - Optional ret = cache.get(key); + Optional ret = this.cache.get(key); if (ret == null) { return null; } @@ -75,23 +94,23 @@ public class AbstractConfiguration implements LuckPermsConfiguration, CacheLoade @Override public void loadAll() { - ConfigKeys.getAllKeys().values().forEach(cache::get); - contextsFile.load(); + ConfigKeys.getAllKeys().values().forEach(this.cache::get); + this.contextsFile.load(); } @Override public void reload() { - adapter.reload(); + this.adapter.reload(); - Set> toInvalidate = cache.asMap().keySet().stream().filter(k -> !(k instanceof EnduringKey)).collect(Collectors.toSet()); - cache.invalidateAll(toInvalidate); + Set> toInvalidate = this.cache.asMap().keySet().stream().filter(k -> !(k instanceof EnduringKey)).collect(Collectors.toSet()); + this.cache.invalidateAll(toInvalidate); loadAll(); getPlugin().getEventFactory().handleConfigReload(); } @Override - public Optional load(ConfigKey key) { - return Optional.ofNullable(key.get(adapter)); + public Optional load(@Nonnull ConfigKey key) { + return Optional.ofNullable(key.get(this.adapter)); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/ConfigKeys.java b/common/src/main/java/me/lucko/luckperms/common/config/ConfigKeys.java index 152636457..6790b7af6 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/ConfigKeys.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/ConfigKeys.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.config; -import lombok.experimental.UtilityClass; - import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; @@ -65,7 +63,6 @@ import java.util.function.Function; /** * All of the {@link ConfigKey}s used by LuckPerms. */ -@UtilityClass public class ConfigKeys { /** @@ -502,4 +499,6 @@ public class ConfigKeys { return KEYS; } + private ConfigKeys() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/ContextsFile.java b/common/src/main/java/me/lucko/luckperms/common/config/ContextsFile.java index d4bd288eb..a94b1abbd 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/ContextsFile.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/ContextsFile.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.config; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.Setter; - import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonObject; @@ -46,21 +42,19 @@ import java.nio.file.Files; /** * A wrapper for the 'contexts.json' file. */ -@RequiredArgsConstructor public class ContextsFile { private final LuckPermsConfiguration configuration; - @Getter - @Setter private ImmutableContextSet staticContexts = ImmutableContextSet.empty(); - - @Getter - @Setter private ImmutableContextSet defaultContexts = ImmutableContextSet.empty(); + public ContextsFile(LuckPermsConfiguration configuration) { + this.configuration = configuration; + } + public void load() { - File file = new File(configuration.getPlugin().getConfigDirectory(), "contexts.json"); - File oldFile = new File(configuration.getPlugin().getConfigDirectory(), "static-contexts.json"); + File file = new File(this.configuration.getPlugin().getConfigDirectory(), "contexts.json"); + File oldFile = new File(this.configuration.getPlugin().getConfigDirectory(), "static-contexts.json"); if (oldFile.exists()) { oldFile.renameTo(file); } @@ -75,16 +69,16 @@ public class ContextsFile { JsonObject data = new Gson().fromJson(reader, JsonObject.class); if (data.has("context")) { - staticContexts = ContextSetJsonSerializer.deserializeContextSet(data.get("context").getAsJsonObject()).makeImmutable(); + this.staticContexts = ContextSetJsonSerializer.deserializeContextSet(data.get("context").getAsJsonObject()).makeImmutable(); save = true; } if (data.has("static-contexts")) { - staticContexts = ContextSetJsonSerializer.deserializeContextSet(data.get("static-contexts").getAsJsonObject()).makeImmutable(); + this.staticContexts = ContextSetJsonSerializer.deserializeContextSet(data.get("static-contexts").getAsJsonObject()).makeImmutable(); } if (data.has("default-contexts")) { - defaultContexts = ContextSetJsonSerializer.deserializeContextSet(data.get("default-contexts").getAsJsonObject()).makeImmutable(); + this.defaultContexts = ContextSetJsonSerializer.deserializeContextSet(data.get("default-contexts").getAsJsonObject()).makeImmutable(); } } catch (IOException e) { @@ -97,13 +91,13 @@ public class ContextsFile { } public void save() { - File file = new File(configuration.getPlugin().getConfigDirectory(), "contexts.json"); + File file = new File(this.configuration.getPlugin().getConfigDirectory(), "contexts.json"); try (BufferedWriter writer = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8)) { JsonObject data = new JsonObject(); - data.add("static-contexts", ContextSetJsonSerializer.serializeContextSet(staticContexts)); - data.add("default-contexts", ContextSetJsonSerializer.serializeContextSet(defaultContexts)); + data.add("static-contexts", ContextSetJsonSerializer.serializeContextSet(this.staticContexts)); + data.add("default-contexts", ContextSetJsonSerializer.serializeContextSet(this.defaultContexts)); new GsonBuilder().setPrettyPrinting().create().toJson(data, writer); writer.flush(); @@ -112,4 +106,12 @@ public class ContextsFile { } } + public ImmutableContextSet getStaticContexts() { + return this.staticContexts; + } + + public ImmutableContextSet getDefaultContexts() { + return this.defaultContexts; + } + } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/adapter/AbstractConfigurationAdapter.java b/common/src/main/java/me/lucko/luckperms/common/config/adapter/AbstractConfigurationAdapter.java index 4efcf4448..699730d52 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/adapter/AbstractConfigurationAdapter.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/adapter/AbstractConfigurationAdapter.java @@ -25,15 +25,17 @@ package me.lucko.luckperms.common.config.adapter; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@RequiredArgsConstructor public abstract class AbstractConfigurationAdapter implements ConfigurationAdapter { - - @Getter private final LuckPermsPlugin plugin; + public AbstractConfigurationAdapter(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + @Override + public LuckPermsPlugin getPlugin() { + return this.plugin; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/AbstractKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/AbstractKey.java index c3036b381..dc562d526 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/AbstractKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/AbstractKey.java @@ -25,19 +25,24 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKey; import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; import java.util.function.Function; -@AllArgsConstructor(staticName = "of") public class AbstractKey implements ConfigKey { + public static AbstractKey of(Function function) { + return new AbstractKey<>(function); + } + private final Function function; + private AbstractKey(Function function) { + this.function = function; + } + @Override public T get(ConfigurationAdapter adapter) { - return function.apply(adapter); + return this.function.apply(adapter); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/BooleanKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/BooleanKey.java index 889a0fb8b..3b3b258ab 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/BooleanKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/BooleanKey.java @@ -25,18 +25,24 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKey; import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; -@AllArgsConstructor(staticName = "of") public class BooleanKey implements ConfigKey { + public static BooleanKey of(String path, boolean def) { + return new BooleanKey(path, def); + } + private final String path; private final boolean def; + private BooleanKey(String path, boolean def) { + this.path = path; + this.def = def; + } + @Override public Boolean get(ConfigurationAdapter adapter) { - return adapter.getBoolean(path, def); + return adapter.getBoolean(this.path, this.def); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/EnduringKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/EnduringKey.java index 4a31e95a6..4ab9268c9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/EnduringKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/EnduringKey.java @@ -25,19 +25,27 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; -import lombok.experimental.Delegate; - import me.lucko.luckperms.common.config.ConfigKey; +import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; /** * Wrapper class to mark a config key as enduring (doesn't change in the event of a reload) * @param */ -@AllArgsConstructor(staticName = "wrap") public class EnduringKey implements ConfigKey { - @Delegate + public static EnduringKey wrap(ConfigKey delegate) { + return new EnduringKey<>(delegate); + } + private final ConfigKey delegate; + private EnduringKey(ConfigKey delegate) { + this.delegate = delegate; + } + + @Override + public T get(ConfigurationAdapter adapter) { + return this.delegate.get(adapter); + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/IntegerKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/IntegerKey.java index c1aed4e55..ae42f7c90 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/IntegerKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/IntegerKey.java @@ -25,18 +25,24 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKey; import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; -@AllArgsConstructor(staticName = "of") public class IntegerKey implements ConfigKey { + public static IntegerKey of(String path, int def) { + return new IntegerKey(path, def); + } + private final String path; private final int def; + private IntegerKey(String path, int def) { + this.path = path; + this.def = def; + } + @Override public Integer get(ConfigurationAdapter adapter) { - return adapter.getInt(path, def); + return adapter.getInt(this.path, this.def); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/LowercaseStringKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/LowercaseStringKey.java index 15f94e42b..0ecf42b8e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/LowercaseStringKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/LowercaseStringKey.java @@ -25,18 +25,24 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKey; import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; -@AllArgsConstructor(staticName = "of") public class LowercaseStringKey implements ConfigKey { + public static LowercaseStringKey of(String path, String def) { + return new LowercaseStringKey(path, def); + } + private final String path; private final String def; + private LowercaseStringKey(String path, String def) { + this.path = path; + this.def = def; + } + @Override public String get(ConfigurationAdapter adapter) { - return adapter.getString(path, def).toLowerCase(); + return adapter.getString(this.path, this.def).toLowerCase(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/MapKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/MapKey.java index d467d48a7..0443747f8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/MapKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/MapKey.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import com.google.common.collect.ImmutableMap; import me.lucko.luckperms.common.config.ConfigKey; @@ -34,12 +32,19 @@ import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; import java.util.Map; -@AllArgsConstructor(staticName = "of") public class MapKey implements ConfigKey> { + public static MapKey of(String path) { + return new MapKey(path); + } + private final String path; + private MapKey(String path) { + this.path = path; + } + @Override public Map get(ConfigurationAdapter adapter) { - return ImmutableMap.copyOf(adapter.getMap(path, ImmutableMap.of())); + return ImmutableMap.copyOf(adapter.getMap(this.path, ImmutableMap.of())); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/StaticKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/StaticKey.java index e8a94fcd5..502825c43 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/StaticKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/StaticKey.java @@ -25,17 +25,22 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKey; import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; -@AllArgsConstructor(staticName = "of") public class StaticKey implements ConfigKey { + public static StaticKey of(T val) { + return new StaticKey<>(val); + } + private final T val; + private StaticKey(T val) { + this.val = val; + } + @Override public T get(ConfigurationAdapter adapter) { - return val; + return this.val; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/config/keys/StringKey.java b/common/src/main/java/me/lucko/luckperms/common/config/keys/StringKey.java index 02a0d871b..ab24fc884 100644 --- a/common/src/main/java/me/lucko/luckperms/common/config/keys/StringKey.java +++ b/common/src/main/java/me/lucko/luckperms/common/config/keys/StringKey.java @@ -25,18 +25,24 @@ package me.lucko.luckperms.common.config.keys; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKey; import me.lucko.luckperms.common.config.adapter.ConfigurationAdapter; -@AllArgsConstructor(staticName = "of") public class StringKey implements ConfigKey { + public static StringKey of(String path, String def) { + return new StringKey(path, def); + } + private final String path; private final String def; + private StringKey(String path, String def) { + this.path = path; + this.def = def; + } + @Override public String get(ConfigurationAdapter adapter) { - return adapter.getString(path, def); + return adapter.getString(this.path, this.def); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/contexts/AbstractContextManager.java b/common/src/main/java/me/lucko/luckperms/common/contexts/AbstractContextManager.java index a5fffb849..43fb85d12 100644 --- a/common/src/main/java/me/lucko/luckperms/common/contexts/AbstractContextManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/contexts/AbstractContextManager.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.contexts; -import lombok.NonNull; - import com.github.benmanes.caffeine.cache.CacheLoader; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; @@ -47,6 +45,8 @@ import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; +import javax.annotation.Nonnull; + /** * An abstract implementation of {@link ContextManager} which caches content lookups. * @@ -82,19 +82,26 @@ public abstract class AbstractContextManager implements ContextManager { @Override public Class getSubjectClass() { - return subjectClass; + return this.subjectClass; } @Override - public ImmutableContextSet getApplicableContext(@NonNull T subject) { + public ImmutableContextSet getApplicableContext(T subject) { + if (subject == null) { + throw new NullPointerException("subject"); + } + // this is actually already immutable, but the Contexts method signature returns the interface. // using the makeImmutable method is faster than casting return getApplicableContexts(subject).getContexts().makeImmutable(); } @Override - public Contexts getApplicableContexts(@NonNull T subject) { - return lookupCache.get(subject); + public Contexts getApplicableContexts(T subject) { + if (subject == null) { + throw new NullPointerException("subject"); + } + return this.lookupCache.get(subject); } @Override @@ -106,7 +113,7 @@ public abstract class AbstractContextManager implements ContextManager { @Override public Contexts getStaticContexts() { - return staticLookupCache.get(staticCacheKey); + return this.staticLookupCache.get(this.staticCacheKey); } @Override @@ -130,11 +137,11 @@ public abstract class AbstractContextManager implements ContextManager { public Contexts formContexts(ImmutableContextSet contextSet) { return new Contexts( contextSet, - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), true, - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), false ); } @@ -142,31 +149,35 @@ public abstract class AbstractContextManager implements ContextManager { @Override public void registerCalculator(ContextCalculator calculator) { // calculators registered first should have priority (and be checked last.) - calculators.add(0, calculator); + this.calculators.add(0, calculator); } @Override public void registerStaticCalculator(StaticContextCalculator calculator) { registerCalculator(calculator); - staticCalculators.add(0, calculator); + this.staticCalculators.add(0, calculator); } @Override - public void invalidateCache(@NonNull T subject){ - lookupCache.invalidate(subject); + public void invalidateCache(T subject) { + if (subject == null) { + throw new NullPointerException("subject"); + } + + this.lookupCache.invalidate(subject); } @Override public int getCalculatorsSize() { - return calculators.size(); + return this.calculators.size(); } private final class Loader implements CacheLoader { @Override - public Contexts load(T subject) { + public Contexts load(@Nonnull T subject) { MutableContextSet accumulator = MutableContextSet.create(); - for (ContextCalculator calculator : calculators) { + for (ContextCalculator calculator : AbstractContextManager.this.calculators) { try { MutableContextSet ret = calculator.giveApplicableContext(subject, accumulator); //noinspection ConstantConditions @@ -175,7 +186,7 @@ public abstract class AbstractContextManager implements ContextManager { } accumulator = ret; } catch (Exception e) { - plugin.getLog().warn("An exception was thrown whilst calculating the context of subject " + subject); + AbstractContextManager.this.plugin.getLog().warn("An exception was thrown whilst calculating the context of subject " + subject); e.printStackTrace(); } } @@ -186,10 +197,10 @@ public abstract class AbstractContextManager implements ContextManager { private final class StaticLoader implements CacheLoader { @Override - public Contexts load(Object o) { + public Contexts load(@Nonnull Object o) { MutableContextSet accumulator = MutableContextSet.create(); - for (StaticContextCalculator calculator : staticCalculators) { + for (StaticContextCalculator calculator : AbstractContextManager.this.staticCalculators) { try { MutableContextSet ret = calculator.giveApplicableContext(accumulator); //noinspection ConstantConditions @@ -198,7 +209,7 @@ public abstract class AbstractContextManager implements ContextManager { } accumulator = ret; } catch (Exception e) { - plugin.getLog().warn("An exception was thrown whilst calculating static contexts"); + AbstractContextManager.this.plugin.getLog().warn("An exception was thrown whilst calculating static contexts"); e.printStackTrace(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetConfigurateSerializer.java b/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetConfigurateSerializer.java index 5a52beb80..119963610 100644 --- a/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetConfigurateSerializer.java +++ b/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetConfigurateSerializer.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.contexts; -import lombok.experimental.UtilityClass; - import com.google.common.base.Preconditions; import me.lucko.luckperms.api.context.ContextSet; @@ -40,8 +38,7 @@ import java.util.Collection; import java.util.List; import java.util.Map; -@UtilityClass -public class ContextSetConfigurateSerializer { +public final class ContextSetConfigurateSerializer { public static ConfigurationNode serializeContextSet(ContextSet contextSet) { ConfigurationNode data = SimpleConfigurationNode.root(); @@ -87,4 +84,6 @@ public class ContextSetConfigurateSerializer { return map; } + private ContextSetConfigurateSerializer() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetJsonSerializer.java b/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetJsonSerializer.java index 10bd08fc5..42a7b05db 100644 --- a/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetJsonSerializer.java +++ b/common/src/main/java/me/lucko/luckperms/common/contexts/ContextSetJsonSerializer.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.contexts; -import lombok.experimental.UtilityClass; - import com.google.common.base.Preconditions; import com.google.gson.Gson; import com.google.gson.JsonArray; @@ -41,9 +39,9 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Map; +import java.util.Objects; -@UtilityClass -public class ContextSetJsonSerializer { +public final class ContextSetJsonSerializer { public static JsonObject serializeContextSet(ContextSet contextSet) { JsonObject data = new JsonObject(); @@ -68,7 +66,7 @@ public class ContextSetJsonSerializer { } public static ContextSet deserializeContextSet(Gson gson, String json) { - Preconditions.checkNotNull(json, "json"); + Objects.requireNonNull(json, "json"); if (json.equals("{}")) { return ContextSet.empty(); } @@ -106,4 +104,6 @@ public class ContextSetJsonSerializer { return map; } + private ContextSetJsonSerializer() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/contexts/LuckPermsCalculator.java b/common/src/main/java/me/lucko/luckperms/common/contexts/LuckPermsCalculator.java index dfd665734..9d990c14a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/contexts/LuckPermsCalculator.java +++ b/common/src/main/java/me/lucko/luckperms/common/contexts/LuckPermsCalculator.java @@ -25,26 +25,30 @@ package me.lucko.luckperms.common.contexts; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.context.MutableContextSet; import me.lucko.luckperms.api.context.StaticContextCalculator; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.config.LuckPermsConfiguration; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class LuckPermsCalculator implements StaticContextCalculator { private final LuckPermsConfiguration config; + public LuckPermsCalculator(LuckPermsConfiguration config) { + this.config = config; + } + + @Nonnull @Override - public MutableContextSet giveApplicableContext(MutableContextSet accumulator) { - String server = config.get(ConfigKeys.SERVER); + public MutableContextSet giveApplicableContext(@Nonnull MutableContextSet accumulator) { + String server = this.config.get(ConfigKeys.SERVER); if (!server.equals("global")) { accumulator.add(Contexts.SERVER_KEY, server); } - accumulator.addAll(config.getContextsFile().getStaticContexts()); + accumulator.addAll(this.config.getContextsFile().getStaticContexts()); return accumulator; } diff --git a/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java b/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java index 236bc3c1b..02420e342 100644 --- a/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java +++ b/common/src/main/java/me/lucko/luckperms/common/dependencies/Dependency.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.dependencies; -import lombok.Getter; - import com.google.common.io.ByteStreams; import java.io.InputStream; @@ -35,7 +33,6 @@ import java.security.MessageDigest; import java.util.Arrays; import java.util.Base64; -@Getter public enum Dependency { CAFFEINE( @@ -171,4 +168,16 @@ public enum Dependency { } } } + + public String getUrl() { + return this.url; + } + + public String getVersion() { + return this.version; + } + + public byte[] getChecksum() { + return this.checksum; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/dependencies/DependencyManager.java b/common/src/main/java/me/lucko/luckperms/common/dependencies/DependencyManager.java index 5a0a735b8..071ae8a6a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/dependencies/DependencyManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/dependencies/DependencyManager.java @@ -99,7 +99,7 @@ public class DependencyManager { dependencies.addAll(STORAGE_DEPENDENCIES.get(storageType)); } - if (plugin.getConfiguration().get(ConfigKeys.REDIS_ENABLED)) { + if (this.plugin.getConfiguration().get(ConfigKeys.REDIS_ENABLED)) { dependencies.add(Dependency.JEDIS); } @@ -110,7 +110,7 @@ public class DependencyManager { } // don't load configurate dependencies on sponge - if (plugin.getServerType() == PlatformType.SPONGE) { + if (this.plugin.getServerType() == PlatformType.SPONGE) { dependencies.remove(Dependency.CONFIGURATE_CORE); dependencies.remove(Dependency.CONFIGURATE_GSON); dependencies.remove(Dependency.CONFIGURATE_YAML); @@ -122,9 +122,9 @@ public class DependencyManager { } public void loadDependencies(Set dependencies) { - plugin.getLog().info("Identified the following dependencies: " + dependencies.toString()); + this.plugin.getLog().info("Identified the following dependencies: " + dependencies.toString()); - File libDir = new File(plugin.getDataDirectory(), "lib"); + File libDir = new File(this.plugin.getDataDirectory(), "lib"); if (!(libDir.exists() || libDir.mkdirs())) { throw new RuntimeException("Unable to create lib dir - " + libDir.getPath()); } @@ -135,7 +135,7 @@ public class DependencyManager { try { filesToLoad.add(downloadDependency(libDir, dependency)); } catch (Throwable e) { - plugin.getLog().severe("Exception whilst downloading dependency " + dependency.name()); + this.plugin.getLog().severe("Exception whilst downloading dependency " + dependency.name()); e.printStackTrace(); } } @@ -145,7 +145,7 @@ public class DependencyManager { try { loadJar(file); } catch (Throwable t) { - plugin.getLog().severe("Failed to load dependency jar " + file.getName()); + this.plugin.getLog().severe("Failed to load dependency jar " + file.getName()); t.printStackTrace(); } } @@ -161,7 +161,7 @@ public class DependencyManager { URL url = new URL(dependency.getUrl()); - plugin.getLog().info("Dependency '" + fileName + "' could not be found. Attempting to download."); + this.plugin.getLog().info("Dependency '" + fileName + "' could not be found. Attempting to download."); try (InputStream in = url.openStream()) { byte[] bytes = ByteStreams.toByteArray(in); if (bytes.length == 0) { @@ -170,7 +170,7 @@ public class DependencyManager { byte[] hash = this.digest.digest(bytes); - plugin.getLog().info("Successfully downloaded '" + fileName + "' with checksum: " + Base64.getEncoder().encodeToString(hash)); + this.plugin.getLog().info("Successfully downloaded '" + fileName + "' with checksum: " + Base64.getEncoder().encodeToString(hash)); if (!Arrays.equals(hash, dependency.getChecksum())) { throw new RuntimeException("Downloaded file had an invalid hash. Expected: " + Base64.getEncoder().encodeToString(dependency.getChecksum())); @@ -188,7 +188,7 @@ public class DependencyManager { private void loadJar(File file) { // get the classloader to load into - ClassLoader classLoader = plugin.getClass().getClassLoader(); + ClassLoader classLoader = this.plugin.getClass().getClassLoader(); if (classLoader instanceof URLClassLoader) { try { diff --git a/common/src/main/java/me/lucko/luckperms/common/event/AbstractEvent.java b/common/src/main/java/me/lucko/luckperms/common/event/AbstractEvent.java index f2b634364..28f1cab27 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/AbstractEvent.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/AbstractEvent.java @@ -25,16 +25,22 @@ package me.lucko.luckperms.common.event; -import lombok.Getter; -import lombok.Setter; - import me.lucko.luckperms.api.LuckPermsApi; import me.lucko.luckperms.api.event.LuckPermsEvent; +import javax.annotation.Nonnull; + public abstract class AbstractEvent implements LuckPermsEvent { - @Getter - @Setter private LuckPermsApi api = null; + @Nonnull + @Override + public LuckPermsApi getApi() { + return this.api; + } + + public void setApi(LuckPermsApi api) { + this.api = api; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/EventFactory.java b/common/src/main/java/me/lucko/luckperms/common/event/EventFactory.java index 2bfbf6398..c306a288d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/EventFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/EventFactory.java @@ -89,15 +89,15 @@ public final class EventFactory { } public LuckPermsEventBus getEventBus() { - return eventBus; + return this.eventBus; } private void fireEventAsync(LuckPermsEvent event) { - eventBus.fireEventAsync(event); + this.eventBus.fireEventAsync(event); } private void fireEvent(LuckPermsEvent event) { - eventBus.fireEvent(event); + this.eventBus.fireEvent(event); } public void handleGroupCacheLoad(Group group, GroupData data) { diff --git a/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventBus.java b/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventBus.java index 1ff3a9d97..a62bd8c55 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventBus.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventBus.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event; -import lombok.Getter; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.ImmutableSet; import me.lucko.luckperms.api.event.Cancellable; @@ -39,22 +35,32 @@ import me.lucko.luckperms.common.api.LuckPermsApiProvider; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Consumer; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class LuckPermsEventBus implements EventBus { - @Getter private final LuckPermsPlugin plugin; private final LuckPermsApiProvider apiProvider; private final Map, Set>> handlerMap = new ConcurrentHashMap<>(); + public LuckPermsEventBus(LuckPermsPlugin plugin, LuckPermsApiProvider apiProvider) { + this.plugin = plugin; + this.apiProvider = apiProvider; + } + + @Nonnull @Override - public EventHandler subscribe(@NonNull Class eventClass, @NonNull Consumer handler) { + public EventHandler subscribe(@Nonnull Class eventClass, @Nonnull Consumer handler) { + Objects.requireNonNull(eventClass, "eventClass"); + Objects.requireNonNull(handler, "handler"); + if (!eventClass.isInterface()) { throw new IllegalArgumentException("class " + eventClass + " is not an interface"); } @@ -62,7 +68,7 @@ public class LuckPermsEventBus implements EventBus { throw new IllegalArgumentException("class " + eventClass.getName() + " does not implement LuckPermsEvent"); } - Set> handlers = handlerMap.computeIfAbsent(eventClass, c -> ConcurrentHashMap.newKeySet()); + Set> handlers = this.handlerMap.computeIfAbsent(eventClass, c -> ConcurrentHashMap.newKeySet()); LuckPermsEventHandler eventHandler = new LuckPermsEventHandler<>(this, eventClass, handler); handlers.add(eventHandler); @@ -70,10 +76,11 @@ public class LuckPermsEventBus implements EventBus { return eventHandler; } + @Nonnull @SuppressWarnings("unchecked") @Override - public Set> getHandlers(Class eventClass) { - Set> handlers = handlerMap.get(eventClass); + public Set> getHandlers(@Nonnull Class eventClass) { + Set> handlers = this.handlerMap.get(eventClass); if (handlers == null) { return ImmutableSet.of(); } else { @@ -87,7 +94,7 @@ public class LuckPermsEventBus implements EventBus { } public void unregisterHandler(LuckPermsEventHandler handler) { - Set> handlers = handlerMap.get(handler.getEventClass()); + Set> handlers = this.handlerMap.get(handler.getEventClass()); if (handlers != null) { handlers.remove(handler); } @@ -95,10 +102,10 @@ public class LuckPermsEventBus implements EventBus { public void fireEvent(LuckPermsEvent event) { if (event instanceof AbstractEvent) { - ((AbstractEvent) event).setApi(apiProvider); + ((AbstractEvent) event).setApi(this.apiProvider); } - for (Map.Entry, Set>> ent : handlerMap.entrySet()) { + for (Map.Entry, Set>> ent : this.handlerMap.entrySet()) { if (!ent.getKey().isAssignableFrom(event.getClass())) { continue; } @@ -111,6 +118,10 @@ public class LuckPermsEventBus implements EventBus { if (event instanceof Cancellable) { throw new IllegalArgumentException("cannot call Cancellable event async"); } - plugin.getScheduler().doAsync(() -> fireEvent(event)); + this.plugin.getScheduler().doAsync(() -> fireEvent(event)); + } + + public LuckPermsPlugin getPlugin() { + return this.plugin; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventHandler.java b/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventHandler.java index 1d093ed26..c423dbb58 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventHandler.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/LuckPermsEventHandler.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.event; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.event.EventHandler; import me.lucko.luckperms.api.event.LuckPermsEvent; @@ -35,49 +32,66 @@ import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Consumer; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class LuckPermsEventHandler implements EventHandler { private final LuckPermsEventBus eventBus; - @Getter private final Class eventClass; - @Getter private final Consumer consumer; private final AtomicBoolean active = new AtomicBoolean(true); private final AtomicInteger callCount = new AtomicInteger(0); + public LuckPermsEventHandler(LuckPermsEventBus eventBus, Class eventClass, Consumer consumer) { + this.eventBus = eventBus; + this.eventClass = eventClass; + this.consumer = consumer; + } + @Override public boolean isActive() { - return active.get(); + return this.active.get(); } @Override public boolean unregister() { // already unregistered - if (!active.getAndSet(false)) { + if (!this.active.getAndSet(false)) { return false; } - eventBus.unregisterHandler(this); + this.eventBus.unregisterHandler(this); return true; } @Override public int getCallCount() { - return callCount.get(); + return this.callCount.get(); } @SuppressWarnings("unchecked") // we know that this method will never be called if the class doesn't match eventClass void handle(LuckPermsEvent event) { try { T t = (T) event; - consumer.accept(t); - callCount.incrementAndGet(); + this.consumer.accept(t); + this.callCount.incrementAndGet(); } catch (Throwable t) { - eventBus.getPlugin().getLog().warn("Unable to pass event " + event.getClass().getSimpleName() + " to handler " + consumer.getClass().getName()); + this.eventBus.getPlugin().getLog().warn("Unable to pass event " + event.getClass().getSimpleName() + " to handler " + this.consumer.getClass().getName()); t.printStackTrace(); } } + + @Nonnull + @Override + public Class getEventClass() { + return this.eventClass; + } + + @Nonnull + @Override + public Consumer getConsumer() { + return this.consumer; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventConfigReload.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventConfigReload.java index 0586b4e45..04ec6b9d3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventConfigReload.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventConfigReload.java @@ -25,12 +25,13 @@ package me.lucko.luckperms.common.event.impl; -import lombok.ToString; - import me.lucko.luckperms.api.event.sync.ConfigReloadEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@ToString public class EventConfigReload extends AbstractEvent implements ConfigReloadEvent { + @Override + public String toString() { + return "EventConfigReload()"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCacheLoad.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCacheLoad.java index a737c59a3..31489aed1 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCacheLoad.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCacheLoad.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.caching.GroupData; import me.lucko.luckperms.api.event.group.GroupCacheLoadEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventGroupCacheLoad extends AbstractEvent implements GroupCacheLoadEvent { private final Group group; private final GroupData loadedData; + public EventGroupCacheLoad(Group group, GroupData loadedData) { + this.group = group; + this.loadedData = loadedData; + } + + @Nonnull + @Override + public Group getGroup() { + return this.group; + } + + @Nonnull + @Override + public GroupData getLoadedData() { + return this.loadedData; + } + + @Override + public String toString() { + return "EventGroupCacheLoad(group=" + this.getGroup() + ", loadedData=" + this.getLoadedData() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCreate.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCreate.java index af798a18c..632250cef 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCreate.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupCreate.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.api.event.group.GroupCreateEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventGroupCreate extends AbstractEvent implements GroupCreateEvent { private final Group group; private final CreationCause cause; + public EventGroupCreate(Group group, CreationCause cause) { + this.group = group; + this.cause = cause; + } + + @Nonnull + @Override + public Group getGroup() { + return this.group; + } + + @Nonnull + @Override + public CreationCause getCause() { + return this.cause; + } + + @Override + public String toString() { + return "EventGroupCreate(group=" + this.getGroup() + ", cause=" + this.getCause() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDataRecalculate.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDataRecalculate.java index 16e5c7ecb..416cf90e3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDataRecalculate.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDataRecalculate.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.caching.GroupData; import me.lucko.luckperms.api.event.group.GroupDataRecalculateEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventGroupDataRecalculate extends AbstractEvent implements GroupDataRecalculateEvent { private final Group group; private final GroupData data; + public EventGroupDataRecalculate(Group group, GroupData data) { + this.group = group; + this.data = data; + } + + @Nonnull + @Override + public Group getGroup() { + return this.group; + } + + @Nonnull + @Override + public GroupData getData() { + return this.data; + } + + @Override + public String toString() { + return "EventGroupDataRecalculate(group=" + this.getGroup() + ", data=" + this.getData() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDelete.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDelete.java index 74e164f3d..eacc131c4 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDelete.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupDelete.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.event.cause.DeletionCause; import me.lucko.luckperms.api.event.group.GroupDeleteEvent; @@ -36,13 +32,40 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.Set; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventGroupDelete extends AbstractEvent implements GroupDeleteEvent { private final String groupName; private final Set existingData; private final DeletionCause cause; + public EventGroupDelete(String groupName, Set existingData, DeletionCause cause) { + this.groupName = groupName; + this.existingData = existingData; + this.cause = cause; + } + + @Nonnull + @Override + public String getGroupName() { + return this.groupName; + } + + @Nonnull + @Override + public Set getExistingData() { + return this.existingData; + } + + @Nonnull + @Override + public DeletionCause getCause() { + return this.cause; + } + + @Override + public String toString() { + return "EventGroupDelete(groupName=" + this.getGroupName() + ", existingData=" + this.getExistingData() + ", cause=" + this.getCause() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoad.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoad.java index 87f10fe39..305d7f91a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoad.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoad.java @@ -25,19 +25,28 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.event.group.GroupLoadEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventGroupLoad extends AbstractEvent implements GroupLoadEvent { private final Group group; + public EventGroupLoad(Group group) { + this.group = group; + } + + @Nonnull + @Override + public Group getGroup() { + return this.group; + } + + @Override + public String toString() { + return "EventGroupLoad(group=" + this.getGroup() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoadAll.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoadAll.java index acd065855..b411fce54 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoadAll.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventGroupLoadAll.java @@ -25,12 +25,13 @@ package me.lucko.luckperms.common.event.impl; -import lombok.ToString; - import me.lucko.luckperms.api.event.group.GroupLoadAllEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@ToString public class EventGroupLoadAll extends AbstractEvent implements GroupLoadAllEvent { + @Override + public String toString() { + return "EventGroupLoadAll()"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogBroadcast.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogBroadcast.java index f991678ec..43a79c0c5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogBroadcast.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogBroadcast.java @@ -25,23 +25,46 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.api.event.log.LogBroadcastEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.concurrent.atomic.AtomicBoolean; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventLogBroadcast extends AbstractEvent implements LogBroadcastEvent { private final AtomicBoolean cancellationState; private final LogEntry entry; private final Origin origin; + public EventLogBroadcast(AtomicBoolean cancellationState, LogEntry entry, Origin origin) { + this.cancellationState = cancellationState; + this.entry = entry; + this.origin = origin; + } + + @Nonnull + @Override + public AtomicBoolean getCancellationState() { + return this.cancellationState; + } + + @Nonnull + @Override + public LogEntry getEntry() { + return this.entry; + } + + @Nonnull + @Override + public Origin getOrigin() { + return this.origin; + } + + @Override + public String toString() { + return "EventLogBroadcast(cancellationState=" + this.getCancellationState() + ", entry=" + this.getEntry() + ", origin=" + this.getOrigin() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNetworkPublish.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNetworkPublish.java index ca88ef3a5..2afc2880c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNetworkPublish.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNetworkPublish.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.api.event.log.LogNetworkPublishEvent; import me.lucko.luckperms.common.event.AbstractEvent; @@ -36,13 +32,40 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.UUID; import java.util.concurrent.atomic.AtomicBoolean; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventLogNetworkPublish extends AbstractEvent implements LogNetworkPublishEvent { private final AtomicBoolean cancellationState; private final UUID logId; private final LogEntry entry; + public EventLogNetworkPublish(AtomicBoolean cancellationState, UUID logId, LogEntry entry) { + this.cancellationState = cancellationState; + this.logId = logId; + this.entry = entry; + } + + @Nonnull + @Override + public AtomicBoolean getCancellationState() { + return this.cancellationState; + } + + @Nonnull + @Override + public UUID getLogId() { + return this.logId; + } + + @Nonnull + @Override + public LogEntry getEntry() { + return this.entry; + } + + @Override + public String toString() { + return "EventLogNetworkPublish(cancellationState=" + this.getCancellationState() + ", logId=" + this.getLogId() + ", entry=" + this.getEntry() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNotify.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNotify.java index 319473df2..fbe77a347 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNotify.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogNotify.java @@ -25,12 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.api.event.log.LogBroadcastEvent; import me.lucko.luckperms.api.event.log.LogNotifyEvent; @@ -41,9 +35,8 @@ import java.util.Optional; import java.util.UUID; import java.util.concurrent.atomic.AtomicBoolean; -@Getter -@ToString -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class EventLogNotify extends AbstractEvent implements LogNotifyEvent { private final AtomicBoolean cancellationState; @@ -51,42 +44,81 @@ public class EventLogNotify extends AbstractEvent implements LogNotifyEvent { private final LogBroadcastEvent.Origin origin; private final Sender sender; - @Getter(AccessLevel.NONE) private Notifiable notifiable; - @Override - public synchronized Notifiable getNotifiable() { - if (notifiable == null) { - notifiable = new SenderNotifiable(sender); - } - return notifiable; + public EventLogNotify(AtomicBoolean cancellationState, LogEntry entry, LogBroadcastEvent.Origin origin, Sender sender) { + this.cancellationState = cancellationState; + this.entry = entry; + this.origin = origin; + this.sender = sender; + } + + @Nonnull + @Override + public synchronized Notifiable getNotifiable() { + if (this.notifiable == null) { + this.notifiable = new SenderNotifiable(this.sender); + } + return this.notifiable; + } + + @Nonnull + @Override + public AtomicBoolean getCancellationState() { + return this.cancellationState; + } + + @Nonnull + @Override + public LogEntry getEntry() { + return this.entry; + } + + @Nonnull + @Override + public LogBroadcastEvent.Origin getOrigin() { + return this.origin; + } + + public Sender getSender() { + return this.sender; + } + + @Override + public String toString() { + return "EventLogNotify(cancellationState=" + this.getCancellationState() + ", entry=" + this.getEntry() + ", origin=" + this.getOrigin() + ", sender=" + this.getSender() + ", notifiable=" + this.getNotifiable() + ")"; } - @AllArgsConstructor private static final class SenderNotifiable implements Notifiable { private final Sender sender; - @Override - public Optional getUuid() { - if (sender.isConsole()) { - return Optional.empty(); - } - return Optional.of(sender.getUuid()); + public SenderNotifiable(Sender sender) { + this.sender = sender; } + @Nonnull + @Override + public Optional getUuid() { + if (this.sender.isConsole()) { + return Optional.empty(); + } + return Optional.of(this.sender.getUuid()); + } + + @Nonnull @Override public String getName() { - return sender.getName(); + return this.sender.getName(); } @Override public boolean isConsole() { - return sender.isConsole(); + return this.sender.isConsole(); } @Override public boolean isPlayer() { - return !sender.isConsole(); + return !this.sender.isConsole(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogPublish.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogPublish.java index 8aaa2e80a..262cb80e8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogPublish.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogPublish.java @@ -25,22 +25,38 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.api.event.log.LogPublishEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.concurrent.atomic.AtomicBoolean; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventLogPublish extends AbstractEvent implements LogPublishEvent { private final AtomicBoolean cancellationState; private final LogEntry entry; + public EventLogPublish(AtomicBoolean cancellationState, LogEntry entry) { + this.cancellationState = cancellationState; + this.entry = entry; + } + + @Nonnull + @Override + public AtomicBoolean getCancellationState() { + return this.cancellationState; + } + + @Nonnull + @Override + public LogEntry getEntry() { + return this.entry; + } + + @Override + public String toString() { + return "EventLogPublish(cancellationState=" + this.getCancellationState() + ", entry=" + this.getEntry() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogReceive.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogReceive.java index 8f70ec727..bc271ebe5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogReceive.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventLogReceive.java @@ -25,22 +25,38 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.api.event.log.LogReceiveEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.UUID; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventLogReceive extends AbstractEvent implements LogReceiveEvent { private final UUID logId; private final LogEntry entry; + public EventLogReceive(UUID logId, LogEntry entry) { + this.logId = logId; + this.entry = entry; + } + + @Nonnull + @Override + public UUID getLogId() { + return this.logId; + } + + @Nonnull + @Override + public LogEntry getEntry() { + return this.entry; + } + + @Override + public String toString() { + return "EventLogReceive(logId=" + this.getLogId() + ", entry=" + this.getEntry() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeAdd.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeAdd.java index d24287060..436d1d0f9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeAdd.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeAdd.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.PermissionHolder; @@ -38,9 +34,8 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.Set; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventNodeAdd extends AbstractEvent implements NodeAddEvent { private final Node node; @@ -48,13 +43,49 @@ public class EventNodeAdd extends AbstractEvent implements NodeAddEvent { private final Set dataBefore; private final Set dataAfter; + public EventNodeAdd(Node node, PermissionHolder target, Set dataBefore, Set dataAfter) { + this.node = node; + this.target = target; + this.dataBefore = dataBefore; + this.dataAfter = dataAfter; + } + @Override public boolean isUser() { - return target instanceof User; + return this.target instanceof User; } @Override public boolean isGroup() { - return target instanceof Group; + return this.target instanceof Group; + } + + @Nonnull + @Override + public Node getNode() { + return this.node; + } + + @Nonnull + @Override + public PermissionHolder getTarget() { + return this.target; + } + + @Nonnull + @Override + public Set getDataBefore() { + return this.dataBefore; + } + + @Nonnull + @Override + public Set getDataAfter() { + return this.dataAfter; + } + + @Override + public String toString() { + return "EventNodeAdd(node=" + this.getNode() + ", target=" + this.getTarget() + ", dataBefore=" + this.getDataBefore() + ", dataAfter=" + this.getDataAfter() + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeClear.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeClear.java index 3d72686d1..ab8c78b26 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeClear.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeClear.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.PermissionHolder; @@ -38,23 +34,50 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.Set; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventNodeClear extends AbstractEvent implements NodeClearEvent { private final PermissionHolder target; private final Set dataBefore; private final Set dataAfter; + public EventNodeClear(PermissionHolder target, Set dataBefore, Set dataAfter) { + this.target = target; + this.dataBefore = dataBefore; + this.dataAfter = dataAfter; + } + @Override public boolean isUser() { - return target instanceof User; + return this.target instanceof User; } @Override public boolean isGroup() { - return target instanceof Group; + return this.target instanceof Group; } + @Nonnull + @Override + public PermissionHolder getTarget() { + return this.target; + } + + @Nonnull + @Override + public Set getDataBefore() { + return this.dataBefore; + } + + @Nonnull + @Override + public Set getDataAfter() { + return this.dataAfter; + } + + @Override + public String toString() { + return "EventNodeClear(target=" + this.getTarget() + ", dataBefore=" + this.getDataBefore() + ", dataAfter=" + this.getDataAfter() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeRemove.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeRemove.java index 827a61291..b51c4975c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeRemove.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventNodeRemove.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Group; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.PermissionHolder; @@ -38,9 +34,8 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.Set; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventNodeRemove extends AbstractEvent implements NodeRemoveEvent { private final Node node; @@ -48,14 +43,49 @@ public class EventNodeRemove extends AbstractEvent implements NodeRemoveEvent { private final Set dataBefore; private final Set dataAfter; + public EventNodeRemove(Node node, PermissionHolder target, Set dataBefore, Set dataAfter) { + this.node = node; + this.target = target; + this.dataBefore = dataBefore; + this.dataAfter = dataAfter; + } + @Override public boolean isUser() { - return target instanceof User; + return this.target instanceof User; } @Override public boolean isGroup() { - return target instanceof Group; + return this.target instanceof Group; } + @Nonnull + @Override + public Node getNode() { + return this.node; + } + + @Nonnull + @Override + public PermissionHolder getTarget() { + return this.target; + } + + @Nonnull + @Override + public Set getDataBefore() { + return this.dataBefore; + } + + @Nonnull + @Override + public Set getDataAfter() { + return this.dataAfter; + } + + @Override + public String toString() { + return "EventNodeRemove(node=" + this.getNode() + ", target=" + this.getTarget() + ", dataBefore=" + this.getDataBefore() + ", dataAfter=" + this.getDataAfter() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPostSync.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPostSync.java index 2f970741a..e7c6efa28 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPostSync.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPostSync.java @@ -25,12 +25,13 @@ package me.lucko.luckperms.common.event.impl; -import lombok.ToString; - import me.lucko.luckperms.api.event.sync.PostSyncEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@ToString public class EventPostSync extends AbstractEvent implements PostSyncEvent { + @Override + public String toString() { + return "EventPostSync()"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreNetworkSync.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreNetworkSync.java index 4faa55038..8b9dc4303 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreNetworkSync.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreNetworkSync.java @@ -25,22 +25,38 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.event.sync.PreNetworkSyncEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.UUID; import java.util.concurrent.atomic.AtomicBoolean; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventPreNetworkSync extends AbstractEvent implements PreNetworkSyncEvent { private final AtomicBoolean cancellationState; private final UUID syncId; + public EventPreNetworkSync(AtomicBoolean cancellationState, UUID syncId) { + this.cancellationState = cancellationState; + this.syncId = syncId; + } + + @Nonnull + @Override + public AtomicBoolean getCancellationState() { + return this.cancellationState; + } + + @Nonnull + @Override + public UUID getSyncId() { + return this.syncId; + } + + @Override + public String toString() { + return "EventPreNetworkSync(cancellationState=" + this.getCancellationState() + ", syncId=" + this.getSyncId() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreSync.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreSync.java index 0e65d0b32..10c998bd0 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreSync.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventPreSync.java @@ -25,20 +25,29 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.event.sync.PreSyncEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.concurrent.atomic.AtomicBoolean; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventPreSync extends AbstractEvent implements PreSyncEvent { private final AtomicBoolean cancellationState; + public EventPreSync(AtomicBoolean cancellationState) { + this.cancellationState = cancellationState; + } + + @Nonnull + @Override + public AtomicBoolean getCancellationState() { + return this.cancellationState; + } + + @Override + public String toString() { + return "EventPreSync(cancellationState=" + this.getCancellationState() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackAddGroup.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackAddGroup.java index 057dad44e..783a59602 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackAddGroup.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackAddGroup.java @@ -25,19 +25,14 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.event.track.mutate.TrackAddGroupEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.List; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventTrackAddGroup extends AbstractEvent implements TrackAddGroupEvent { private final String group; @@ -45,4 +40,39 @@ public class EventTrackAddGroup extends AbstractEvent implements TrackAddGroupEv private final List dataBefore; private final List dataAfter; + public EventTrackAddGroup(String group, Track track, List dataBefore, List dataAfter) { + this.group = group; + this.track = track; + this.dataBefore = dataBefore; + this.dataAfter = dataAfter; + } + + @Nonnull + @Override + public String getGroup() { + return this.group; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Nonnull + @Override + public List getDataBefore() { + return this.dataBefore; + } + + @Nonnull + @Override + public List getDataAfter() { + return this.dataAfter; + } + + @Override + public String toString() { + return "EventTrackAddGroup(group=" + this.getGroup() + ", track=" + this.getTrack() + ", dataBefore=" + this.getDataBefore() + ", dataAfter=" + this.getDataAfter() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackClear.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackClear.java index c5b00e059..bcde2c090 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackClear.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackClear.java @@ -25,23 +25,46 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.event.track.mutate.TrackClearEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.List; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventTrackClear extends AbstractEvent implements TrackClearEvent { private final Track track; private final List dataBefore; private final List dataAfter; + public EventTrackClear(Track track, List dataBefore, List dataAfter) { + this.track = track; + this.dataBefore = dataBefore; + this.dataAfter = dataAfter; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Nonnull + @Override + public List getDataBefore() { + return this.dataBefore; + } + + @Nonnull + @Override + public List getDataAfter() { + return this.dataAfter; + } + + @Override + public String toString() { + return "EventTrackClear(track=" + this.getTrack() + ", dataBefore=" + this.getDataBefore() + ", dataAfter=" + this.getDataAfter() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackCreate.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackCreate.java index 740280194..79e0ac38d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackCreate.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackCreate.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.api.event.track.TrackCreateEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventTrackCreate extends AbstractEvent implements TrackCreateEvent { private final Track track; private final CreationCause cause; + public EventTrackCreate(Track track, CreationCause cause) { + this.track = track; + this.cause = cause; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Nonnull + @Override + public CreationCause getCause() { + return this.cause; + } + + @Override + public String toString() { + return "EventTrackCreate(track=" + this.getTrack() + ", cause=" + this.getCause() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackDelete.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackDelete.java index 3989eedb9..86e3f8d2e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackDelete.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackDelete.java @@ -25,23 +25,46 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.event.cause.DeletionCause; import me.lucko.luckperms.api.event.track.TrackDeleteEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.List; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventTrackDelete extends AbstractEvent implements TrackDeleteEvent { private final String trackName; private final List existingData; private final DeletionCause cause; + public EventTrackDelete(String trackName, List existingData, DeletionCause cause) { + this.trackName = trackName; + this.existingData = existingData; + this.cause = cause; + } + + @Nonnull + @Override + public String getTrackName() { + return this.trackName; + } + + @Nonnull + @Override + public List getExistingData() { + return this.existingData; + } + + @Nonnull + @Override + public DeletionCause getCause() { + return this.cause; + } + + @Override + public String toString() { + return "EventTrackDelete(trackName=" + this.getTrackName() + ", existingData=" + this.getExistingData() + ", cause=" + this.getCause() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoad.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoad.java index be49ebe62..e66635a89 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoad.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoad.java @@ -25,19 +25,28 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.event.track.TrackLoadEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventTrackLoad extends AbstractEvent implements TrackLoadEvent { private final Track track; + public EventTrackLoad(Track track) { + this.track = track; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Override + public String toString() { + return "EventTrackLoad(track=" + this.getTrack() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoadAll.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoadAll.java index bd9a6827c..32313202b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoadAll.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackLoadAll.java @@ -25,12 +25,13 @@ package me.lucko.luckperms.common.event.impl; -import lombok.ToString; - import me.lucko.luckperms.api.event.track.TrackLoadAllEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@ToString public class EventTrackLoadAll extends AbstractEvent implements TrackLoadAllEvent { + @Override + public String toString() { + return "EventTrackLoadAll()"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackRemoveGroup.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackRemoveGroup.java index 271729ce2..80b570ad2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackRemoveGroup.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventTrackRemoveGroup.java @@ -25,19 +25,14 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.event.track.mutate.TrackRemoveGroupEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.List; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventTrackRemoveGroup extends AbstractEvent implements TrackRemoveGroupEvent { private final String group; @@ -45,4 +40,39 @@ public class EventTrackRemoveGroup extends AbstractEvent implements TrackRemoveG private final List dataBefore; private final List dataAfter; + public EventTrackRemoveGroup(String group, Track track, List dataBefore, List dataAfter) { + this.group = group; + this.track = track; + this.dataBefore = dataBefore; + this.dataAfter = dataAfter; + } + + @Nonnull + @Override + public String getGroup() { + return this.group; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Nonnull + @Override + public List getDataBefore() { + return this.dataBefore; + } + + @Nonnull + @Override + public List getDataAfter() { + return this.dataAfter; + } + + @Override + public String toString() { + return "EventTrackRemoveGroup(group=" + this.getGroup() + ", track=" + this.getTrack() + ", dataBefore=" + this.getDataBefore() + ", dataAfter=" + this.getDataAfter() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserCacheLoad.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserCacheLoad.java index 5f5bca3fe..b42927f07 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserCacheLoad.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserCacheLoad.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.caching.UserData; import me.lucko.luckperms.api.event.user.UserCacheLoadEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserCacheLoad extends AbstractEvent implements UserCacheLoadEvent { private final User user; private final UserData loadedData; + public EventUserCacheLoad(User user, UserData loadedData) { + this.user = user; + this.loadedData = loadedData; + } + + @Nonnull + @Override + public User getUser() { + return this.user; + } + + @Nonnull + @Override + public UserData getLoadedData() { + return this.loadedData; + } + + @Override + public String toString() { + return "EventUserCacheLoad(user=" + this.getUser() + ", loadedData=" + this.getLoadedData() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDataRecalculate.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDataRecalculate.java index f94537a4d..f4ab49f07 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDataRecalculate.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDataRecalculate.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.caching.UserData; import me.lucko.luckperms.api.event.user.UserDataRecalculateEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserDataRecalculate extends AbstractEvent implements UserDataRecalculateEvent { private final User user; private final UserData data; + public EventUserDataRecalculate(User user, UserData data) { + this.user = user; + this.data = data; + } + + @Nonnull + @Override + public User getUser() { + return this.user; + } + + @Nonnull + @Override + public UserData getData() { + return this.data; + } + + @Override + public String toString() { + return "EventUserDataRecalculate(user=" + this.getUser() + ", data=" + this.getData() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDemote.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDemote.java index d778efcec..c499b8ab9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDemote.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserDemote.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.event.user.track.TrackAction; @@ -37,31 +33,56 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.Optional; -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserDemote extends AbstractEvent implements UserDemoteEvent { - @Getter private final Track track; - @Getter private final User user; private final String groupFrom; private final String groupTo; + public EventUserDemote(Track track, User user, String groupFrom, String groupTo) { + this.track = track; + this.user = user; + this.groupFrom = groupFrom; + this.groupTo = groupTo; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Nonnull + @Override + public User getUser() { + return this.user; + } + + @Nonnull @Override public TrackAction getAction() { return TrackAction.DEMOTION; } + @Nonnull @Override public Optional getGroupFrom() { - return Optional.ofNullable(groupFrom); + return Optional.ofNullable(this.groupFrom); + } + + @Nonnull + @Override + public Optional getGroupTo() { + return Optional.ofNullable(this.groupTo); } @Override - public Optional getGroupTo() { - return Optional.ofNullable(groupTo); + public String toString() { + return "EventUserDemote(track=" + this.track + ", user=" + this.user + ", groupFrom=" + this.getGroupFrom() + ", groupTo=" + this.getGroupTo() + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserFirstLogin.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserFirstLogin.java index d2d144339..4907232cc 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserFirstLogin.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserFirstLogin.java @@ -25,21 +25,37 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.event.user.UserFirstLoginEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.UUID; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserFirstLogin extends AbstractEvent implements UserFirstLoginEvent { private final UUID uuid; private final String username; + public EventUserFirstLogin(UUID uuid, String username) { + this.uuid = uuid; + this.username = username; + } + + @Nonnull + @Override + public UUID getUuid() { + return this.uuid; + } + + @Nonnull + @Override + public String getUsername() { + return this.username; + } + + @Override + public String toString() { + return "EventUserFirstLogin(uuid=" + this.getUuid() + ", username=" + this.getUsername() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoad.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoad.java index cf8f08720..62a7fb7ad 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoad.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoad.java @@ -25,19 +25,28 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.event.user.UserLoadEvent; import me.lucko.luckperms.common.event.AbstractEvent; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserLoad extends AbstractEvent implements UserLoadEvent { private final User user; + public EventUserLoad(User user) { + this.user = user; + } + + @Nonnull + @Override + public User getUser() { + return this.user; + } + + @Override + public String toString() { + return "EventUserLoad(user=" + this.getUser() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoginProcess.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoginProcess.java index 92cc20400..63f2d1589 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoginProcess.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserLoginProcess.java @@ -25,23 +25,45 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.event.user.UserLoginProcessEvent; import me.lucko.luckperms.common.event.AbstractEvent; import java.util.UUID; -@Getter -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserLoginProcess extends AbstractEvent implements UserLoginProcessEvent { private final UUID uuid; private final String username; private final User user; + public EventUserLoginProcess(UUID uuid, String username, User user) { + this.uuid = uuid; + this.username = username; + this.user = user; + } + + @Nonnull + @Override + public UUID getUuid() { + return this.uuid; + } + + @Nonnull + @Override + public String getUsername() { + return this.username; + } + + @Override + public User getUser() { + return this.user; + } + + @Override + public String toString() { + return "EventUserLoginProcess(uuid=" + this.getUuid() + ", username=" + this.getUsername() + ", user=" + this.getUser() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserPromote.java b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserPromote.java index 2dcd9e564..786f5ad56 100644 --- a/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserPromote.java +++ b/common/src/main/java/me/lucko/luckperms/common/event/impl/EventUserPromote.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.event.impl; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Track; import me.lucko.luckperms.api.User; import me.lucko.luckperms.api.event.user.track.TrackAction; @@ -37,31 +33,56 @@ import me.lucko.luckperms.common.event.AbstractEvent; import java.util.Optional; -@ToString -@AllArgsConstructor +import javax.annotation.Nonnull; + public class EventUserPromote extends AbstractEvent implements UserPromoteEvent { - @Getter private final Track track; - @Getter private final User user; private final String groupFrom; private final String groupTo; + public EventUserPromote(Track track, User user, String groupFrom, String groupTo) { + this.track = track; + this.user = user; + this.groupFrom = groupFrom; + this.groupTo = groupTo; + } + + @Nonnull + @Override + public Track getTrack() { + return this.track; + } + + @Nonnull + @Override + public User getUser() { + return this.user; + } + + @Nonnull @Override public TrackAction getAction() { return TrackAction.PROMOTION; } + @Nonnull @Override public Optional getGroupFrom() { - return Optional.ofNullable(groupFrom); + return Optional.ofNullable(this.groupFrom); + } + + @Nonnull + @Override + public Optional getGroupTo() { + return Optional.ofNullable(this.groupTo); } @Override - public Optional getGroupTo() { - return Optional.ofNullable(groupTo); + public String toString() { + return "EventUserPromote(track=" + this.track + ", user=" + this.user + ", groupFrom=" + this.getGroupFrom() + ", groupTo=" + this.getGroupTo() + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpec.java b/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpec.java index 9c76ac05a..63fdef76e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpec.java +++ b/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpec.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.locale; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.common.commands.Arg; @@ -573,10 +571,7 @@ public enum CommandSpec { } private static final class SimpleLocalizedSpec implements LocalizedSpec { - - @Getter private final LocaleManager localeManager; - private final CommandSpec spec; public SimpleLocalizedSpec(CommandSpec spec, LocaleManager localeManager) { @@ -584,34 +579,37 @@ public enum CommandSpec { this.spec = spec; } + @Override public String description() { - CommandSpecData translation = localeManager.getTranslation(spec); + CommandSpecData translation = this.localeManager.getTranslation(this.spec); if (translation != null && translation.getDescription() != null) { return translation.getDescription(); } // fallback - return spec.description; + return this.spec.description; } + @Override public String usage() { - CommandSpecData translation = localeManager.getTranslation(spec); + CommandSpecData translation = this.localeManager.getTranslation(this.spec); if (translation != null && translation.getUsage() != null) { return translation.getUsage(); } // fallback - return spec.usage; + return this.spec.usage; } + @Override public List args() { - CommandSpecData translation = localeManager.getTranslation(spec); + CommandSpecData translation = this.localeManager.getTranslation(this.spec); if (translation == null || translation.getArgs() == null) { // fallback - return spec.args; + return this.spec.args; } - List args = new ArrayList<>(spec.args); + List args = new ArrayList<>(this.spec.args); ListIterator it = args.listIterator(); while (it.hasNext()) { Arg next = it.next(); @@ -625,6 +623,11 @@ public enum CommandSpec { return ImmutableList.copyOf(args); } + + @Override + public LocaleManager getLocaleManager() { + return this.localeManager; + } } /** diff --git a/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpecData.java b/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpecData.java index 1ee80ff00..9f650c6c2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpecData.java +++ b/common/src/main/java/me/lucko/luckperms/common/locale/CommandSpecData.java @@ -25,22 +25,61 @@ package me.lucko.luckperms.common.locale; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import java.util.Map; +import java.util.Objects; + +import javax.annotation.Nonnull; /** * The localized data for a {@link CommandSpec}. */ -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor public final class CommandSpecData { private final String description; private final String usage; private final Map args; + + public CommandSpecData(String description, String usage, Map args) { + this.description = description; + this.usage = usage; + this.args = args; + } + + @Nonnull + public String getDescription() { + return this.description; + } + + @Nonnull + public String getUsage() { + return this.usage; + } + + @Nonnull + public Map getArgs() { + return this.args; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof CommandSpecData)) return false; + final CommandSpecData that = (CommandSpecData) o; + + return this.getDescription().equals(that.getDescription()) && + this.getUsage().equals(that.getUsage()) && + this.getArgs().equals(that.getArgs()); + } + + @Override + public int hashCode() { + return Objects.hash(getDescription(), getUsage(), getArgs()); + } + + @Override + public String toString() { + return "CommandSpecData(" + + "description=" + this.getDescription() + ", " + + "usage=" + this.getUsage() + ", " + + "args=" + this.getArgs() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/locale/Message.java b/common/src/main/java/me/lucko/luckperms/common/locale/Message.java index 05e7e7b18..8514f25fb 100644 --- a/common/src/main/java/me/lucko/luckperms/common/locale/Message.java +++ b/common/src/main/java/me/lucko/luckperms/common/locale/Message.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.locale; -import lombok.Getter; - import me.lucko.luckperms.common.commands.sender.Sender; import me.lucko.luckperms.common.commands.utils.CommandUtils; import me.lucko.luckperms.common.utils.TextUtils; @@ -456,7 +454,6 @@ public enum Message { return s; } - @Getter private final String message; private final boolean showPrefix; @@ -466,6 +463,10 @@ public enum Message { this.showPrefix = showPrefix; } + public String getMessage() { + return this.message; + } + public String asString(LocaleManager localeManager, Object... objects) { String prefix = null; if (localeManager != null) { @@ -480,11 +481,11 @@ public enum Message { s = localeManager.getTranslation(this); } if (s == null) { - s = message; + s = this.message; } s = format(s.replace("{PREFIX}", prefix).replace("\\n", "\n"), objects); - return CommandUtils.color(showPrefix ? prefix + s : s); + return CommandUtils.color(this.showPrefix ? prefix + s : s); } public void send(Sender sender, Object... objects) { diff --git a/common/src/main/java/me/lucko/luckperms/common/locale/NoopLocaleManager.java b/common/src/main/java/me/lucko/luckperms/common/locale/NoopLocaleManager.java index 2fe6c0e0d..d05210727 100644 --- a/common/src/main/java/me/lucko/luckperms/common/locale/NoopLocaleManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/locale/NoopLocaleManager.java @@ -37,7 +37,7 @@ public class NoopLocaleManager implements LocaleManager { } @Override - public void loadFromFile(File file) throws Exception { + public void loadFromFile(File file) { } diff --git a/common/src/main/java/me/lucko/luckperms/common/locale/SimpleLocaleManager.java b/common/src/main/java/me/lucko/luckperms/common/locale/SimpleLocaleManager.java index d79dc9cab..862ff21c0 100644 --- a/common/src/main/java/me/lucko/luckperms/common/locale/SimpleLocaleManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/locale/SimpleLocaleManager.java @@ -42,6 +42,7 @@ public class SimpleLocaleManager implements LocaleManager { private Map messages = ImmutableMap.of(); private Map commands = ImmutableMap.of(); + @Override public void tryLoad(LuckPermsPlugin plugin, File file) { if (file.exists()) { plugin.getLog().info("Found lang.yml - loading messages..."); @@ -53,6 +54,7 @@ public class SimpleLocaleManager implements LocaleManager { } } + @Override @SuppressWarnings("unchecked") public void loadFromFile(File file) throws Exception { try (BufferedReader reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8)) { @@ -116,17 +118,17 @@ public class SimpleLocaleManager implements LocaleManager { @Override public int getSize() { - return messages.size() + commands.size(); + return this.messages.size() + this.commands.size(); } @Override public String getTranslation(Message key) { - return messages.get(key); + return this.messages.get(key); } @Override public CommandSpecData getTranslation(CommandSpec key) { - return commands.get(key); + return this.commands.get(key); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/logging/ProgressLogger.java b/common/src/main/java/me/lucko/luckperms/common/logging/ProgressLogger.java index 1f55a160e..d8c6c880c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/logging/ProgressLogger.java +++ b/common/src/main/java/me/lucko/luckperms/common/logging/ProgressLogger.java @@ -25,16 +25,12 @@ package me.lucko.luckperms.common.logging; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.commands.sender.Sender; import me.lucko.luckperms.common.locale.Message; import java.util.HashSet; import java.util.Set; -@RequiredArgsConstructor public class ProgressLogger { private static final int NOTIFY_FREQUENCY = 500; @@ -42,38 +38,43 @@ public class ProgressLogger { private final Message logMessage; private final Message logProgressMessage; - @Getter private final Set listeners = new HashSet<>(); public ProgressLogger(String pluginName) { this(pluginName, Message.MIGRATION_LOG, Message.MIGRATION_LOG_PROGRESS); } + public ProgressLogger(String pluginName, Message logMessage, Message logProgressMessage) { + this.pluginName = pluginName; + this.logMessage = logMessage; + this.logProgressMessage = logProgressMessage; + } + public void addListener(Sender sender) { - listeners.add(sender); + this.listeners.add(sender); } public void log(String msg) { - if (pluginName == null) { - listeners.forEach(s -> logMessage.send(s, msg)); + if (this.pluginName == null) { + this.listeners.forEach(s -> this.logMessage.send(s, msg)); } else { - listeners.forEach(s -> logMessage.send(s, pluginName, msg)); + this.listeners.forEach(s -> this.logMessage.send(s, this.pluginName, msg)); } } public void logErr(String msg) { - if (pluginName == null) { - listeners.forEach(s -> logMessage.send(s, "Error -> " + msg)); + if (this.pluginName == null) { + this.listeners.forEach(s -> this.logMessage.send(s, "Error -> " + msg)); } else { - listeners.forEach(s -> logMessage.send(s, pluginName, "Error -> " + msg)); + this.listeners.forEach(s -> this.logMessage.send(s, this.pluginName, "Error -> " + msg)); } } public void logAllProgress(String msg, int amount) { - if (pluginName == null) { - listeners.forEach(s -> logProgressMessage.send(s, msg.replace("{}", Integer.toString(amount)))); + if (this.pluginName == null) { + this.listeners.forEach(s -> this.logProgressMessage.send(s, msg.replace("{}", Integer.toString(amount)))); } else { - listeners.forEach(s -> logProgressMessage.send(s, pluginName, msg.replace("{}", Integer.toString(amount)))); + this.listeners.forEach(s -> this.logProgressMessage.send(s, this.pluginName, msg.replace("{}", Integer.toString(amount)))); } } @@ -83,4 +84,8 @@ public class ProgressLogger { logAllProgress(msg, amount); } } + + public Set getListeners() { + return this.listeners; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/logging/SenderLogger.java b/common/src/main/java/me/lucko/luckperms/common/logging/SenderLogger.java index a32581da4..6c355f52f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/logging/SenderLogger.java +++ b/common/src/main/java/me/lucko/luckperms/common/logging/SenderLogger.java @@ -25,40 +25,43 @@ package me.lucko.luckperms.common.logging; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import me.lucko.luckperms.common.commands.sender.Sender; import me.lucko.luckperms.common.commands.utils.CommandUtils; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.locale.Message; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@AllArgsConstructor +import java.util.Objects; + public class SenderLogger implements Logger { private final LuckPermsPlugin plugin; private final Sender console; - @Override - public void info(@NonNull String s) { - msg(Message.LOG_INFO, s); + public SenderLogger(LuckPermsPlugin plugin, Sender console) { + this.plugin = plugin; + this.console = console; } @Override - public void warn(@NonNull String s) { - msg(Message.LOG_WARN, s); + public void info(String s) { + msg(Message.LOG_INFO, Objects.requireNonNull(s)); } @Override - public void severe(@NonNull String s) { - msg(Message.LOG_ERROR, s); + public void warn(String s) { + msg(Message.LOG_WARN, Objects.requireNonNull(s)); + } + + @Override + public void severe(String s) { + msg(Message.LOG_ERROR, Objects.requireNonNull(s)); } private void msg(Message message, String s) { - String msg = message.asString(plugin.getLocaleManager(), s); - if (plugin.getConfiguration() != null && !plugin.getConfiguration().get(ConfigKeys.USE_COLORED_LOGGER)) { + String msg = message.asString(this.plugin.getLocaleManager(), s); + if (this.plugin.getConfiguration() != null && !this.plugin.getConfiguration().get(ConfigKeys.USE_COLORED_LOGGER)) { msg = CommandUtils.stripColor(msg); } - console.sendMessage(msg); + this.console.sendMessage(msg); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java b/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java index 630a3a162..9a8bfc54a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/managers/AbstractManager.java @@ -34,6 +34,8 @@ import me.lucko.luckperms.common.references.Identifiable; import java.util.Map; +import javax.annotation.Nonnull; + /** * An abstract manager class * @@ -45,40 +47,40 @@ public abstract class AbstractManager> implements M private final LoadingCache objects = Caffeine.newBuilder() .build(new CacheLoader() { @Override - public T load(I i) { + public T load(@Nonnull I i) { return apply(i); } @Override - public T reload(I i, T t) { + public T reload(@Nonnull I i, @Nonnull T t) { return t; // Never needs to be refreshed. } }); @Override public Map getAll() { - return ImmutableMap.copyOf(objects.asMap()); + return ImmutableMap.copyOf(this.objects.asMap()); } @Override public T getOrMake(I id) { - return objects.get(sanitizeIdentifier(id)); + return this.objects.get(sanitizeIdentifier(id)); } @Override public T getIfLoaded(I id) { - return objects.getIfPresent(sanitizeIdentifier(id)); + return this.objects.getIfPresent(sanitizeIdentifier(id)); } @Override public boolean isLoaded(I id) { - return objects.asMap().containsKey(sanitizeIdentifier(id)); + return this.objects.asMap().containsKey(sanitizeIdentifier(id)); } @Override public void unload(I id) { if (id != null) { - objects.invalidate(sanitizeIdentifier(id)); + this.objects.invalidate(sanitizeIdentifier(id)); } } @@ -91,7 +93,7 @@ public abstract class AbstractManager> implements M @Override public void unloadAll() { - objects.invalidateAll(); + this.objects.invalidateAll(); } protected I sanitizeIdentifier(I i) { diff --git a/common/src/main/java/me/lucko/luckperms/common/managers/GenericGroupManager.java b/common/src/main/java/me/lucko/luckperms/common/managers/GenericGroupManager.java index c142e9ff7..e9b151004 100644 --- a/common/src/main/java/me/lucko/luckperms/common/managers/GenericGroupManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/managers/GenericGroupManager.java @@ -25,18 +25,19 @@ package me.lucko.luckperms.common.managers; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@RequiredArgsConstructor public class GenericGroupManager extends AbstractManager implements GroupManager { private final LuckPermsPlugin plugin; + public GenericGroupManager(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + @Override public Group apply(String name) { - return new Group(name, plugin); + return new Group(name, this.plugin); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/managers/GenericTrackManager.java b/common/src/main/java/me/lucko/luckperms/common/managers/GenericTrackManager.java index d1feb30a3..3de89a492 100644 --- a/common/src/main/java/me/lucko/luckperms/common/managers/GenericTrackManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/managers/GenericTrackManager.java @@ -25,18 +25,19 @@ package me.lucko.luckperms.common.managers; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.model.Track; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@AllArgsConstructor public class GenericTrackManager extends AbstractManager implements TrackManager { private final LuckPermsPlugin plugin; + public GenericTrackManager(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + @Override public Track apply(String name) { - return new Track(name, plugin); + return new Track(name, this.plugin); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/managers/GenericUserManager.java b/common/src/main/java/me/lucko/luckperms/common/managers/GenericUserManager.java index 6685b09e8..b5346c05c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/managers/GenericUserManager.java +++ b/common/src/main/java/me/lucko/luckperms/common/managers/GenericUserManager.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.managers; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.common.config.ConfigKeys; @@ -39,11 +37,14 @@ import java.util.Optional; import java.util.UUID; import java.util.concurrent.CompletableFuture; -@RequiredArgsConstructor public class GenericUserManager extends AbstractManager implements UserManager { private final LuckPermsPlugin plugin; + public GenericUserManager(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + @Override public User getOrMake(UserIdentifier id) { User ret = super.getOrMake(id); @@ -56,8 +57,8 @@ public class GenericUserManager extends AbstractManager im @Override public User apply(UserIdentifier id) { return !id.getUsername().isPresent() ? - new User(id.getUuid(), plugin) : - new User(id.getUuid(), id.getUsername().get(), plugin); + new User(id.getUuid(), this.plugin) : + new User(id.getUuid(), id.getUsername().get(), this.plugin); } @Override @@ -78,12 +79,12 @@ public class GenericUserManager extends AbstractManager im @Override public boolean giveDefaultIfNeeded(User user, boolean save) { - return giveDefaultIfNeeded(user, save, plugin); + return giveDefaultIfNeeded(user, save, this.plugin); } @Override public boolean cleanup(User user) { - if (!plugin.isPlayerOnline(plugin.getUuidCache().getExternalUUID(user.getUuid()))) { + if (!this.plugin.isPlayerOnline(this.plugin.getUuidCache().getExternalUUID(user.getUuid()))) { unload(user); return true; } else { @@ -93,17 +94,17 @@ public class GenericUserManager extends AbstractManager im @Override public void scheduleUnload(UUID uuid) { - plugin.getScheduler().asyncLater(() -> { + this.plugin.getScheduler().asyncLater(() -> { // check once to see if the user can be unloaded. - if (getIfLoaded(plugin.getUuidCache().getUUID(uuid)) != null && !plugin.isPlayerOnline(uuid)) { + if (getIfLoaded(this.plugin.getUuidCache().getUUID(uuid)) != null && !this.plugin.isPlayerOnline(uuid)) { // check again in 40 ticks, we want to be sure the player won't have re-logged before we unload them. - plugin.getScheduler().asyncLater(() -> { - User user = getIfLoaded(plugin.getUuidCache().getUUID(uuid)); - if (user != null && !plugin.isPlayerOnline(uuid)) { + this.plugin.getScheduler().asyncLater(() -> { + User user = getIfLoaded(this.plugin.getUuidCache().getUUID(uuid)); + if (user != null && !this.plugin.isPlayerOnline(uuid)) { user.getCachedData().invalidateCaches(); unload(user); - plugin.getUuidCache().clearCache(uuid); + this.plugin.getUuidCache().clearCache(uuid); } }, 40L); } @@ -113,10 +114,10 @@ public class GenericUserManager extends AbstractManager im @Override public CompletableFuture updateAllUsers() { return CompletableFuture.runAsync( - () -> plugin.getOnlinePlayers() - .map(u -> plugin.getUuidCache().getUUID(u)) - .forEach(u -> plugin.getStorage().loadUser(u, null).join()), - plugin.getScheduler().async() + () -> this.plugin.getOnlinePlayers() + .map(u -> this.plugin.getUuidCache().getUUID(u)) + .forEach(u -> this.plugin.getStorage().loadUser(u, null).join()), + this.plugin.getScheduler().async() ); } diff --git a/common/src/main/java/me/lucko/luckperms/common/messaging/AbstractMessagingService.java b/common/src/main/java/me/lucko/luckperms/common/messaging/AbstractMessagingService.java index fd7ed8e24..371ee1609 100644 --- a/common/src/main/java/me/lucko/luckperms/common/messaging/AbstractMessagingService.java +++ b/common/src/main/java/me/lucko/luckperms/common/messaging/AbstractMessagingService.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.messaging; -import lombok.Getter; - import com.google.common.collect.Maps; import com.google.gson.Gson; import com.google.gson.GsonBuilder; @@ -58,16 +56,10 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi private static final String USER_UPDATE_HEADER = "userupdate:"; private static final String LOG_HEADER = "log"; - @Getter private final LuckPermsPlugin plugin; - - @Getter private final String name; - private final Set receivedMessages; private final Gson gson; - - @Getter private final BufferedRequest updateBuffer; public AbstractMessagingService(LuckPermsPlugin plugin, String name) { @@ -78,6 +70,20 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi this.updateBuffer = new PushUpdateBuffer(plugin); } + public LuckPermsPlugin getPlugin() { + return this.plugin; + } + + @Override + public String getName() { + return this.name; + } + + @Override + public BufferedRequest getUpdateBuffer() { + return this.updateBuffer; + } + protected abstract void sendMessage(String message); protected void onMessage(String msg, Consumer callback) { @@ -89,17 +95,17 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi return; } - if (!receivedMessages.add(requestId)) { + if (!this.receivedMessages.add(requestId)) { return; } - plugin.getLog().info("[" + name + " Messaging] Received update ping with id: " + requestId.toString()); + this.plugin.getLog().info("[" + this.name + " Messaging] Received update ping with id: " + requestId.toString()); - if (plugin.getEventFactory().handleNetworkPreSync(false, requestId)) { + if (this.plugin.getEventFactory().handleNetworkPreSync(false, requestId)) { return; } - plugin.getUpdateTaskBuffer().request(); + this.plugin.getUpdateTaskBuffer().request(); if (callback != null) { callback.accept(msg); @@ -116,22 +122,22 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi UUID requestId = entry.getKey(); UUID userUuid = entry.getValue(); - if (!receivedMessages.add(requestId)) { + if (!this.receivedMessages.add(requestId)) { return; } - User user = plugin.getUserManager().getIfLoaded(userUuid); + User user = this.plugin.getUserManager().getIfLoaded(userUuid); if (user == null) { return; } - plugin.getLog().info("[" + name + " Messaging] Received user update ping for '" + user.getFriendlyName() + "' with id: " + uuidToString(requestId)); + this.plugin.getLog().info("[" + this.name + " Messaging] Received user update ping for '" + user.getFriendlyName() + "' with id: " + uuidToString(requestId)); - if (plugin.getEventFactory().handleNetworkPreSync(false, requestId)) { + if (this.plugin.getEventFactory().handleNetworkPreSync(false, requestId)) { return; } - plugin.getStorage().loadUser(user.getUuid(), null); + this.plugin.getStorage().loadUser(user.getUuid(), null); if (callback != null) { callback.accept(msg); @@ -142,7 +148,7 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi Map.Entry entry; try { - entry = ExtendedLogEntry.deserialize(gson.fromJson(content, JsonObject.class)); + entry = ExtendedLogEntry.deserialize(this.gson.fromJson(content, JsonObject.class)); } catch (Exception e) { return; } @@ -156,12 +162,12 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi return; } - if (!receivedMessages.add(requestId)) { + if (!this.receivedMessages.add(requestId)) { return; } - plugin.getEventFactory().handleLogReceive(requestId, entry.getValue()); - plugin.getLogDispatcher().dispatchFromRemote(entry.getValue()); + this.plugin.getEventFactory().handleLogReceive(requestId, entry.getValue()); + this.plugin.getLogDispatcher().dispatchFromRemote(entry.getValue()); if (callback != null) { callback.accept(msg); @@ -171,44 +177,44 @@ public abstract class AbstractMessagingService implements ExtendedMessagingServi @Override public void pushUpdate() { - plugin.getScheduler().doAsync(() -> { + this.plugin.getScheduler().doAsync(() -> { UUID requestId = generatePingId(); String strId = uuidToString(requestId); - plugin.getLog().info("[" + name + " Messaging] Sending ping with id: " + strId); + this.plugin.getLog().info("[" + this.name + " Messaging] Sending ping with id: " + strId); sendMessage(UPDATE_HEADER + strId); }); } @Override public void pushUserUpdate(User user) { - plugin.getScheduler().doAsync(() -> { + this.plugin.getScheduler().doAsync(() -> { UUID requestId = generatePingId(); String strId = uuidToString(requestId); - plugin.getLog().info("[" + name + " Messaging] Sending user ping for '" + user.getFriendlyName() + "' with id: " + strId); + this.plugin.getLog().info("[" + this.name + " Messaging] Sending user ping for '" + user.getFriendlyName() + "' with id: " + strId); sendMessage(USER_UPDATE_HEADER + uuidsToString(requestId, user.getUuid())); }); } @Override public void pushLog(LogEntry logEntry) { - plugin.getScheduler().doAsync(() -> { + this.plugin.getScheduler().doAsync(() -> { UUID requestId = generatePingId(); String strId = uuidToString(requestId); - if (plugin.getEventFactory().handleLogNetworkPublish(!plugin.getConfiguration().get(ConfigKeys.PUSH_LOG_ENTRIES), requestId, logEntry)) { + if (this.plugin.getEventFactory().handleLogNetworkPublish(!this.plugin.getConfiguration().get(ConfigKeys.PUSH_LOG_ENTRIES), requestId, logEntry)) { return; } - plugin.getLog().info("[" + name + " Messaging] Sending log with id: " + strId); - sendMessage(LOG_HEADER + gson.toJson(ExtendedLogEntry.serializeWithId(strId, logEntry))); + this.plugin.getLog().info("[" + this.name + " Messaging] Sending log with id: " + strId); + sendMessage(LOG_HEADER + this.gson.toJson(ExtendedLogEntry.serializeWithId(strId, logEntry))); }); } private UUID generatePingId() { UUID uuid = UUID.randomUUID(); - receivedMessages.add(uuid); + this.receivedMessages.add(uuid); return uuid; } diff --git a/common/src/main/java/me/lucko/luckperms/common/messaging/MessagingFactory.java b/common/src/main/java/me/lucko/luckperms/common/messaging/MessagingFactory.java index 5c69b8589..da27b7b35 100644 --- a/common/src/main/java/me/lucko/luckperms/common/messaging/MessagingFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/messaging/MessagingFactory.java @@ -25,22 +25,23 @@ package me.lucko.luckperms.common.messaging; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@RequiredArgsConstructor public class MessagingFactory

{ - - @Getter(AccessLevel.PROTECTED) private final P plugin; + public MessagingFactory(P plugin) { + this.plugin = plugin; + } + + protected P getPlugin() { + return this.plugin; + } + public final ExtendedMessagingService getInstance() { - String messagingType = plugin.getConfiguration().get(ConfigKeys.MESSAGING_SERVICE).toLowerCase(); - if (messagingType.equals("none") && plugin.getConfiguration().get(ConfigKeys.REDIS_ENABLED)) { + String messagingType = this.plugin.getConfiguration().get(ConfigKeys.MESSAGING_SERVICE).toLowerCase(); + if (messagingType.equals("none") && this.plugin.getConfiguration().get(ConfigKeys.REDIS_ENABLED)) { messagingType = "redis"; } @@ -48,30 +49,30 @@ public class MessagingFactory

{ return null; } - plugin.getLog().info("Loading messaging service... [" + messagingType.toUpperCase() + "]"); + this.plugin.getLog().info("Loading messaging service... [" + messagingType.toUpperCase() + "]"); ExtendedMessagingService service = getServiceFor(messagingType); if (service != null) { return service; } - plugin.getLog().warn("Messaging service '" + messagingType + "' not recognised."); + this.plugin.getLog().warn("Messaging service '" + messagingType + "' not recognised."); return null; } protected ExtendedMessagingService getServiceFor(String messagingType) { if (messagingType.equals("redis")) { - if (plugin.getConfiguration().get(ConfigKeys.REDIS_ENABLED)) { - RedisMessagingService redis = new RedisMessagingService(plugin); + if (this.plugin.getConfiguration().get(ConfigKeys.REDIS_ENABLED)) { + RedisMessagingService redis = new RedisMessagingService(this.plugin); try { - redis.init(plugin.getConfiguration().get(ConfigKeys.REDIS_ADDRESS), plugin.getConfiguration().get(ConfigKeys.REDIS_PASSWORD)); + redis.init(this.plugin.getConfiguration().get(ConfigKeys.REDIS_ADDRESS), this.plugin.getConfiguration().get(ConfigKeys.REDIS_PASSWORD)); return redis; } catch (Exception e) { - plugin.getLog().warn("Couldn't load redis..."); + this.plugin.getLog().warn("Couldn't load redis..."); e.printStackTrace(); } } else { - plugin.getLog().warn("Messaging Service was set to redis, but redis is not enabled!"); + this.plugin.getLog().warn("Messaging Service was set to redis, but redis is not enabled!"); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/messaging/RedisMessagingService.java b/common/src/main/java/me/lucko/luckperms/common/messaging/RedisMessagingService.java index e0d2b3dbc..2c28d6b55 100644 --- a/common/src/main/java/me/lucko/luckperms/common/messaging/RedisMessagingService.java +++ b/common/src/main/java/me/lucko/luckperms/common/messaging/RedisMessagingService.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.messaging; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import redis.clients.jedis.shaded.Jedis; @@ -53,15 +51,15 @@ public class RedisMessagingService extends AbstractMessagingService { int port = addressSplit.length > 1 ? Integer.parseInt(addressSplit[1]) : 6379; if (password.equals("")) { - jedisPool = new JedisPool(new JedisPoolConfig(), host, port); + this.jedisPool = new JedisPool(new JedisPoolConfig(), host, port); } else { - jedisPool = new JedisPool(new JedisPoolConfig(), host, port, 0, password); + this.jedisPool = new JedisPool(new JedisPoolConfig(), host, port, 0, password); } - plugin.getScheduler().doAsync(() -> { - sub = new LPSub(this); - try (Jedis jedis = jedisPool.getResource()) { - jedis.subscribe(sub, CHANNEL); + this.plugin.getScheduler().doAsync(() -> { + this.sub = new LPSub(this); + try (Jedis jedis = this.jedisPool.getResource()) { + jedis.subscribe(this.sub, CHANNEL); } catch (Exception e) { e.printStackTrace(); } @@ -70,29 +68,32 @@ public class RedisMessagingService extends AbstractMessagingService { @Override public void close() { - sub.unsubscribe(); - jedisPool.destroy(); + this.sub.unsubscribe(); + this.jedisPool.destroy(); } @Override protected void sendMessage(String message) { - try (Jedis jedis = jedisPool.getResource()) { + try (Jedis jedis = this.jedisPool.getResource()) { jedis.publish(CHANNEL, message); } catch (Exception e) { e.printStackTrace(); } } - @RequiredArgsConstructor private static class LPSub extends JedisPubSub { private final RedisMessagingService parent; + public LPSub(RedisMessagingService parent) { + this.parent = parent; + } + @Override public void onMessage(String channel, String msg) { if (!channel.equals(CHANNEL)) { return; } - parent.onMessage(msg, null); + this.parent.onMessage(msg, null); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStack.java b/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStack.java index d0b2dd1dc..237060498 100644 --- a/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStack.java +++ b/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStack.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.metastacking; -import lombok.AccessLevel; -import lombok.Getter; - import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.metastacking.MetaStackDefinition; @@ -36,13 +33,11 @@ import me.lucko.luckperms.common.utils.ImmutableCollectors; import java.util.ArrayList; import java.util.List; -@Getter public final class SimpleMetaStack implements MetaStack { private final MetaStackDefinition definition; private final ChatMetaType targetType; - @Getter(AccessLevel.NONE) private final List entries; public SimpleMetaStack(MetaStackDefinition definition, ChatMetaType targetType) { @@ -55,7 +50,7 @@ public final class SimpleMetaStack implements MetaStack { @Override public String toFormattedString() { - List ret = new ArrayList<>(entries); + List ret = new ArrayList<>(this.entries); ret.removeIf(m -> !m.getCurrentValue().isPresent()); if (ret.isEmpty()) { @@ -63,22 +58,32 @@ public final class SimpleMetaStack implements MetaStack { } StringBuilder sb = new StringBuilder(); - sb.append(definition.getStartSpacer()); + sb.append(this.definition.getStartSpacer()); for (int i = 0; i < ret.size(); i++) { if (i != 0) { - sb.append(definition.getMiddleSpacer()); + sb.append(this.definition.getMiddleSpacer()); } MetaStackEntry e = ret.get(i); sb.append(e.getCurrentValue().get().getValue()); } - sb.append(definition.getEndSpacer()); + sb.append(this.definition.getEndSpacer()); return sb.toString(); } @Override public void accumulateToAll(LocalizedNode node) { - entries.forEach(e -> e.accumulateNode(node)); + this.entries.forEach(e -> e.accumulateNode(node)); + } + + @Override + public MetaStackDefinition getDefinition() { + return this.definition; + } + + @Override + public ChatMetaType getTargetType() { + return this.targetType; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackDefinition.java b/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackDefinition.java index f27b89ba8..f468dda05 100644 --- a/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackDefinition.java +++ b/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackDefinition.java @@ -25,19 +25,16 @@ package me.lucko.luckperms.common.metastacking; -import lombok.Getter; -import lombok.NonNull; -import lombok.ToString; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.metastacking.MetaStackDefinition; import me.lucko.luckperms.api.metastacking.MetaStackElement; import java.util.List; +import java.util.Objects; + +import javax.annotation.Nonnull; -@Getter -@ToString public final class SimpleMetaStackDefinition implements MetaStackDefinition { private final List elements; @@ -48,38 +45,65 @@ public final class SimpleMetaStackDefinition implements MetaStackDefinition { // cache hashcode - this class is immutable, and used an index in MetaContexts private final int hashCode; - public SimpleMetaStackDefinition(@NonNull List elements, @NonNull String startSpacer, @NonNull String middleSpacer, @NonNull String endSpacer) { - this.elements = ImmutableList.copyOf(elements); - this.startSpacer = startSpacer; - this.middleSpacer = middleSpacer; - this.endSpacer = endSpacer; + public SimpleMetaStackDefinition(List elements, String startSpacer, String middleSpacer, String endSpacer) { + this.elements = ImmutableList.copyOf(Objects.requireNonNull(elements, "elements")); + this.startSpacer = Objects.requireNonNull(startSpacer, "startSpacer"); + this.middleSpacer = Objects.requireNonNull(middleSpacer, "middleSpacer"); + this.endSpacer = Objects.requireNonNull(endSpacer, "endSpacer"); this.hashCode = calculateHashCode(); } + @Nonnull + @Override + public List getElements() { + return this.elements; + } + + @Nonnull + @Override + public String getStartSpacer() { + return this.startSpacer; + } + + @Nonnull + @Override + public String getMiddleSpacer() { + return this.middleSpacer; + } + + @Nonnull + @Override + public String getEndSpacer() { + return this.endSpacer; + } + + public int getHashCode() { + return this.hashCode; + } + @Override public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof SimpleMetaStackDefinition)) return false; - final SimpleMetaStackDefinition other = (SimpleMetaStackDefinition) o; + final SimpleMetaStackDefinition that = (SimpleMetaStackDefinition) o; - return this.getElements().equals(other.getElements()) && - this.getStartSpacer().equals(other.getStartSpacer()) && - this.getMiddleSpacer().equals(other.getMiddleSpacer()) && - this.getEndSpacer().equals(other.getEndSpacer()); + return this.getElements().equals(that.getElements()) && + this.getStartSpacer().equals(that.getStartSpacer()) && + this.getMiddleSpacer().equals(that.getMiddleSpacer()) && + this.getEndSpacer().equals(that.getEndSpacer()); } private int calculateHashCode() { - final int PRIME = 59; - int result = 1; - result = result * PRIME + this.getElements().hashCode(); - result = result * PRIME + this.getStartSpacer().hashCode(); - result = result * PRIME + this.getMiddleSpacer().hashCode(); - result = result * PRIME + this.getEndSpacer().hashCode(); - return result; + return Objects.hash(getElements(), getStartSpacer(), getMiddleSpacer(), getEndSpacer()); } @Override public int hashCode() { - return hashCode; + return this.hashCode; + } + + @Override + public String toString() { + return "SimpleMetaStackDefinition(elements=" + this.getElements() + ", startSpacer=" + this.getStartSpacer() + ", middleSpacer=" + this.getMiddleSpacer() + ", endSpacer=" + this.getEndSpacer() + ", hashCode=" + this.getHashCode() + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackEntry.java b/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackEntry.java index 2988fa399..ddeeed15b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackEntry.java +++ b/common/src/main/java/me/lucko/luckperms/common/metastacking/SimpleMetaStackEntry.java @@ -25,12 +25,6 @@ package me.lucko.luckperms.common.metastacking; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.metastacking.MetaStackElement; @@ -38,30 +32,71 @@ import me.lucko.luckperms.api.metastacking.MetaStackElement; import java.util.Map; import java.util.Optional; -@Getter -@ToString -@EqualsAndHashCode(of = {"element", "type", "current"}) -@RequiredArgsConstructor final class SimpleMetaStackEntry implements MetaStackEntry { private final MetaStack parentStack; private final MetaStackElement element; private final ChatMetaType type; - @Getter(AccessLevel.NONE) private Map.Entry current = null; + public SimpleMetaStackEntry(MetaStack parentStack, MetaStackElement element, ChatMetaType type) { + this.parentStack = parentStack; + this.element = element; + this.type = type; + } + @Override public Optional> getCurrentValue() { - return Optional.ofNullable(current); + return Optional.ofNullable(this.current); } @Override public boolean accumulateNode(LocalizedNode node) { - if (element.shouldAccumulate(node, type, current)) { - this.current = type.getEntry(node); + if (this.element.shouldAccumulate(node, this.type, this.current)) { + this.current = this.type.getEntry(node); return true; } return false; } + + @Override + public MetaStack getParentStack() { + return this.parentStack; + } + + @Override + public MetaStackElement getElement() { + return this.element; + } + + public ChatMetaType getType() { + return this.type; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof SimpleMetaStackEntry)) return false; + final SimpleMetaStackEntry that = (SimpleMetaStackEntry) o; + + return this.getElement().equals(that.getElement()) && + this.getType() == that.getType() && + this.current.equals(that.current); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.getElement().hashCode(); + result = result * PRIME + this.getType().hashCode(); + result = result * PRIME + this.current.hashCode(); + return result; + } + + @Override + public String toString() { + return "SimpleMetaStackEntry(parentStack=" + this.getParentStack() + ", element=" + this.getElement() + ", type=" + this.getType() + ", current=" + this.current + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/metastacking/StandardStackElements.java b/common/src/main/java/me/lucko/luckperms/common/metastacking/StandardStackElements.java index 9e7b5ba0f..d3d622539 100644 --- a/common/src/main/java/me/lucko/luckperms/common/metastacking/StandardStackElements.java +++ b/common/src/main/java/me/lucko/luckperms/common/metastacking/StandardStackElements.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.common.metastacking; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; -import lombok.ToString; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.ChatMetaType; import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.metastacking.MetaStackElement; @@ -42,11 +37,12 @@ import java.util.Map; import java.util.Optional; import java.util.UUID; +import javax.annotation.Nonnull; + /** * Contains the standard {@link MetaStackElement}s provided by LuckPerms. */ -@UtilityClass -public class StandardStackElements { +public final class StandardStackElements { private static final HighestPriority HIGHEST_PRIORITY = new HighestPriority(); private static final LowestPriority LOWEST_PRIORITY = new LowestPriority(); private static final HighestPriorityOwn HIGHEST_PRIORITY_OWN = new HighestPriorityOwn(); @@ -178,10 +174,9 @@ public class StandardStackElements { return t == null || t.containsGroup(node.getLocation()); } - @ToString private static final class HighestPriority implements MetaStackElement { @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } @@ -189,12 +184,16 @@ public class StandardStackElements { Map.Entry newEntry = type.getEntry(node); return !compareEntriesHighest(current, newEntry); } + + @Override + public String toString() { + return "StandardStackElements.HighestPriority()"; + } } - @ToString private static final class HighestPriorityOwn implements MetaStackElement { @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } @@ -206,12 +205,16 @@ public class StandardStackElements { Map.Entry newEntry = type.getEntry(node); return !compareEntriesHighest(current, newEntry); } + + @Override + public String toString() { + return "StandardStackElements.HighestPriorityOwn()"; + } } - @ToString private static final class HighestPriorityInherited implements MetaStackElement { @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } @@ -223,48 +226,92 @@ public class StandardStackElements { Map.Entry newEntry = type.getEntry(node); return !compareEntriesHighest(current, newEntry); } + + @Override + public String toString() { + return "StandardStackElements.HighestPriorityInherited()"; + } } - @ToString(of = "trackName") - @RequiredArgsConstructor - @EqualsAndHashCode(of = "trackName") private static final class HighestPriorityTrack implements MetaStackElement { private final LuckPermsPlugin plugin; private final String trackName; + public HighestPriorityTrack(LuckPermsPlugin plugin, String trackName) { + this.plugin = plugin; + this.trackName = trackName; + } + @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } Map.Entry newEntry = type.getEntry(node); - return !compareEntriesHighest(current, newEntry) && !checkTrackElement(plugin, node, trackName); + return !compareEntriesHighest(current, newEntry) && !checkTrackElement(this.plugin, node, this.trackName); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof HighestPriorityTrack)) return false; + final HighestPriorityTrack other = (HighestPriorityTrack) o; + return this.trackName.equals(other.trackName); + } + + @Override + public int hashCode() { + return this.trackName.hashCode(); + } + + @Override + public String toString() { + return "StandardStackElements.HighestPriorityTrack(trackName=" + this.trackName + ")"; } } - @ToString(of = "trackName") - @RequiredArgsConstructor - @EqualsAndHashCode(of = "trackName") private static final class HighestPriorityNotOnTrack implements MetaStackElement { private final LuckPermsPlugin plugin; private final String trackName; + public HighestPriorityNotOnTrack(LuckPermsPlugin plugin, String trackName) { + this.plugin = plugin; + this.trackName = trackName; + } + @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } Map.Entry newEntry = type.getEntry(node); - return !compareEntriesHighest(current, newEntry) && !checkNotTrackElement(plugin, node, trackName); + return !compareEntriesHighest(current, newEntry) && !checkNotTrackElement(this.plugin, node, this.trackName); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof HighestPriorityNotOnTrack)) return false; + final HighestPriorityNotOnTrack other = (HighestPriorityNotOnTrack) o; + return this.trackName.equals(other.trackName); + } + + @Override + public int hashCode() { + return this.trackName.hashCode(); + } + + @Override + public String toString() { + return "StandardStackElements.HighestPriorityNotOnTrack(trackName=" + this.trackName + ")"; } } - @ToString private static final class LowestPriority implements MetaStackElement { @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } @@ -272,12 +319,16 @@ public class StandardStackElements { Map.Entry newEntry = type.getEntry(node); return !compareEntriesLowest(current, newEntry); } + + @Override + public String toString() { + return "StandardStackElements.LowestPriority()"; + } } - @ToString private static final class LowestPriorityOwn implements MetaStackElement { @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } @@ -289,12 +340,16 @@ public class StandardStackElements { Map.Entry newEntry = type.getEntry(node); return !compareEntriesLowest(current, newEntry); } + + @Override + public String toString() { + return "StandardStackElements.LowestPriorityOwn()"; + } } - @ToString private static final class LowestPriorityInherited implements MetaStackElement { @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } @@ -306,41 +361,89 @@ public class StandardStackElements { Map.Entry newEntry = type.getEntry(node); return !compareEntriesLowest(current, newEntry); } + + @Override + public String toString() { + return "StandardStackElements.LowestPriorityInherited()"; + } } - @ToString(of = "trackName") - @RequiredArgsConstructor - @EqualsAndHashCode(of = "trackName") private static final class LowestPriorityTrack implements MetaStackElement { private final LuckPermsPlugin plugin; private final String trackName; + public LowestPriorityTrack(LuckPermsPlugin plugin, String trackName) { + this.plugin = plugin; + this.trackName = trackName; + } + @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } Map.Entry entry = type.getEntry(node); - return !compareEntriesLowest(current, entry) && !checkTrackElement(plugin, node, trackName); + return !compareEntriesLowest(current, entry) && !checkTrackElement(this.plugin, node, this.trackName); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof LowestPriorityTrack)) return false; + final LowestPriorityTrack other = (LowestPriorityTrack) o; + return this.trackName.equals(other.trackName); + } + + @Override + public int hashCode() { + return this.trackName.hashCode(); + } + + @Override + public String toString() { + return "StandardStackElements.LowestPriorityTrack(trackName=" + this.trackName + ")"; } } - @ToString(of = "trackName") - @RequiredArgsConstructor - @EqualsAndHashCode(of = "trackName") private static final class LowestPriorityNotOnTrack implements MetaStackElement { private final LuckPermsPlugin plugin; private final String trackName; + public LowestPriorityNotOnTrack(LuckPermsPlugin plugin, String trackName) { + this.plugin = plugin; + this.trackName = trackName; + } + @Override - public boolean shouldAccumulate(LocalizedNode node, ChatMetaType type, Map.Entry current) { + public boolean shouldAccumulate(@Nonnull LocalizedNode node, @Nonnull ChatMetaType type, Map.Entry current) { if (type.shouldIgnore(node)) { return false; } Map.Entry newEntry = type.getEntry(node); - return !compareEntriesLowest(current, newEntry) && !checkNotTrackElement(plugin, node, trackName); + return !compareEntriesLowest(current, newEntry) && !checkNotTrackElement(this.plugin, node, this.trackName); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof LowestPriorityNotOnTrack)) return false; + final LowestPriorityNotOnTrack other = (LowestPriorityNotOnTrack) o; + return this.trackName.equals(other.trackName); + } + + @Override + public int hashCode() { + return this.trackName.hashCode(); + } + + @Override + public String toString() { + return "StandardStackElements.LowestPriorityNotOnTrack(trackName=" + this.trackName + ")"; } } + + private StandardStackElements() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/model/Group.java b/common/src/main/java/me/lucko/luckperms/common/model/Group.java index b01cac92e..dce31b2a5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/model/Group.java +++ b/common/src/main/java/me/lucko/luckperms/common/model/Group.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.model; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.common.api.delegates.model.ApiGroup; @@ -43,26 +39,20 @@ import me.lucko.luckperms.common.references.Identifiable; import java.util.Optional; import java.util.concurrent.CompletableFuture; -@ToString(of = {"name"}) -@EqualsAndHashCode(of = {"name"}, callSuper = false) public class Group extends PermissionHolder implements Identifiable { /** * The name of the group */ - @Getter private final String name; - @Getter private final ApiGroup delegate = new ApiGroup(this); /** * The groups data cache instance */ - @Getter private final GroupCachedData cachedData; - @Getter private final BufferedRequest refreshBuffer; public Group(String name, LuckPermsPlugin plugin) { @@ -71,15 +61,34 @@ public class Group extends PermissionHolder implements Identifiable { this.refreshBuffer = new GroupRefreshBuffer(plugin, this); this.cachedData = new GroupCachedData(this); - getPlugin().getEventFactory().handleGroupCacheLoad(this, cachedData); + getPlugin().getEventFactory().handleGroupCacheLoad(this, this.cachedData); // invalidate out caches when data is updated - getStateListeners().add(() -> refreshBuffer.request()); + getStateListeners().add(this.refreshBuffer::request); + } + + public String getName() { + return this.name; + } + + @Override + public ApiGroup getDelegate() { + return this.delegate; + } + + @Override + public GroupCachedData getCachedData() { + return this.cachedData; + } + + @Override + public BufferedRequest getRefreshBuffer() { + return this.refreshBuffer; } @Override public String getId() { - return name; + return this.name; } public Optional getDisplayName() { @@ -104,7 +113,7 @@ public class Group extends PermissionHolder implements Identifiable { @Override public String getFriendlyName() { Optional dn = getDisplayName(); - return dn.map(s -> name + " (" + s + ")").orElse(name); + return dn.map(s -> this.name + " (" + s + ")").orElse(this.name); } @Override @@ -119,9 +128,27 @@ public class Group extends PermissionHolder implements Identifiable { private CompletableFuture reloadCachedData() { return CompletableFuture.allOf( - cachedData.reloadPermissions(), - cachedData.reloadMeta() - ).thenAccept(n -> getPlugin().getEventFactory().handleGroupDataRecalculate(this, cachedData)); + this.cachedData.reloadPermissions(), + this.cachedData.reloadMeta() + ).thenAccept(n -> getPlugin().getEventFactory().handleGroupDataRecalculate(this, this.cachedData)); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof Group)) return false; + final Group other = (Group) o; + return this.name.equals(other.name); + } + + @Override + public int hashCode() { + return this.name.hashCode(); + } + + @Override + public String toString() { + return "Group(name=" + this.name + ")"; } private static final class GroupRefreshBuffer extends BufferedRequest { @@ -134,7 +161,7 @@ public class Group extends PermissionHolder implements Identifiable { @Override protected Void perform() { - return group.reloadCachedData().join(); + return this.group.reloadCachedData().join(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/model/PermissionHolder.java b/common/src/main/java/me/lucko/luckperms/common/model/PermissionHolder.java index 52a10fead..d5ea28d55 100644 --- a/common/src/main/java/me/lucko/luckperms/common/model/PermissionHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/model/PermissionHolder.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.model; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -104,7 +100,6 @@ import java.util.stream.Collectors; * contexts they apply in, so doing context specific querying should be fast. Caching would be ineffective here, due to * the potentially vast amount of contexts being used by nodes, and the potential for very large inheritance trees.

*/ -@RequiredArgsConstructor(access = AccessLevel.PROTECTED) public abstract class PermissionHolder { /** @@ -115,13 +110,11 @@ public abstract class PermissionHolder { *

For users, this value is a String representation of their {@link User#getUuid()}. For groups, it's just the * {@link Group#getName()}.

*/ - @Getter private final String objectName; /** * Reference to the main plugin instance */ - @Getter private final LuckPermsPlugin plugin; /** @@ -137,17 +130,22 @@ public abstract class PermissionHolder { .treeSetValues(NodeComparator.reverse()) .build(); + protected PermissionHolder(String objectName, LuckPermsPlugin plugin) { + this.objectName = objectName; + this.plugin = plugin; + } + /** * Caches an immutable copy of the above nodes multimap */ private final class NodesCache extends Cache> { @Override protected ImmutableSetMultimap supply() { - nodesLock.lock(); + PermissionHolder.this.nodesLock.lock(); try { - return ImmutableSetMultimap.copyOf(nodes); + return ImmutableSetMultimap.copyOf(PermissionHolder.this.nodes); } finally { - nodesLock.unlock(); + PermissionHolder.this.nodesLock.unlock(); } } } @@ -179,11 +177,11 @@ public abstract class PermissionHolder { private final class TransientNodesCache extends Cache> { @Override protected ImmutableSetMultimap supply() { - transientNodesLock.lock(); + PermissionHolder.this.transientNodesLock.lock(); try { - return ImmutableSetMultimap.copyOf(transientNodes); + return ImmutableSetMultimap.copyOf(PermissionHolder.this.transientNodes); } finally { - transientNodesLock.unlock(); + PermissionHolder.this.transientNodesLock.unlock(); } } } @@ -206,7 +204,6 @@ public abstract class PermissionHolder { /** * Lock used by Storage implementations to prevent concurrent read/writes */ - @Getter private final Lock ioLock = new ReentrantLock(); /** @@ -217,16 +214,31 @@ public abstract class PermissionHolder { /** * A set of runnables which are called when this objects state changes. */ - @Getter private final Set stateListeners = ConcurrentHashMap.newKeySet(); + public String getObjectName() { + return this.objectName; + } + + public LuckPermsPlugin getPlugin() { + return this.plugin; + } + + public Lock getIoLock() { + return this.ioLock; + } + + public Set getStateListeners() { + return this.stateListeners; + } + private void invalidateCache() { - nodesCopy.invalidate(); - transientNodesCopy.invalidate(); - weightCache.invalidate(); + this.nodesCopy.invalidate(); + this.transientNodesCopy.invalidate(); + this.weightCache.invalidate(); // Invalidate listeners - for (StateListener listener : stateListeners) { + for (StateListener listener : this.stateListeners) { try { listener.onStateChange(); } catch (Exception e) { @@ -242,7 +254,7 @@ public abstract class PermissionHolder { /* only declare state of groups. the state manager isn't really being used now the caches in this class are gone, but it's useful for command output. */ if (this.getType().isGroup()) { - plugin.getCachedStateManager().putAll(toReference(), getGroupReferences()); + this.plugin.getCachedStateManager().putAll(toReference(), getGroupReferences()); } } @@ -289,7 +301,7 @@ public abstract class PermissionHolder { * @return an immutable copy of the multimap storing this objects nodes */ public ImmutableSetMultimap getEnduringNodes() { - return nodesCopy.get(); + return this.nodesCopy.get(); } /** @@ -298,7 +310,7 @@ public abstract class PermissionHolder { * @return an immutable copy of the multimap storing this objects transient nodes */ public ImmutableSetMultimap getTransientNodes() { - return transientNodesCopy.get(); + return this.transientNodesCopy.get(); } /** @@ -307,14 +319,14 @@ public abstract class PermissionHolder { * @param set the set of nodes to apply to the object */ public void setEnduringNodes(Set set) { - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.clear(); + this.nodes.clear(); for (Node n : set) { - nodes.put(n.getFullContexts().makeImmutable(), n); + this.nodes.put(n.getFullContexts().makeImmutable(), n); } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); } @@ -325,36 +337,36 @@ public abstract class PermissionHolder { * @param multimap the replacement multimap */ public void replaceEnduringNodes(Multimap multimap) { - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.clear(); - nodes.putAll(multimap); + this.nodes.clear(); + this.nodes.putAll(multimap); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); } public void setTransientNodes(Set set) { - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - transientNodes.clear(); + this.transientNodes.clear(); for (Node n : set) { - transientNodes.put(n.getFullContexts().makeImmutable(), n); + this.transientNodes.put(n.getFullContexts().makeImmutable(), n); } } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } invalidateCache(); } public void replaceTransientNodes(Multimap multimap) { - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - transientNodes.clear(); - transientNodes.putAll(multimap); + this.transientNodes.clear(); + this.transientNodes.putAll(multimap); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } invalidateCache(); } @@ -367,18 +379,18 @@ public abstract class PermissionHolder { public LinkedHashSet getOwnNodesSet() { LinkedHashSet ret = new LinkedHashSet<>(); - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - ret.addAll(transientNodes.values()); + ret.addAll(this.transientNodes.values()); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } - nodesLock.lock(); + this.nodesLock.lock(); try { - ret.addAll(nodes.values()); + ret.addAll(this.nodes.values()); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } return ret; @@ -387,18 +399,18 @@ public abstract class PermissionHolder { public List getOwnNodes() { List ret = new ArrayList<>(); - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - ret.addAll(transientNodes.values()); + ret.addAll(this.transientNodes.values()); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } - nodesLock.lock(); + this.nodesLock.lock(); try { - ret.addAll(nodes.values()); + ret.addAll(this.nodes.values()); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } return ret; @@ -407,22 +419,22 @@ public abstract class PermissionHolder { public SortedSet getOwnNodesSorted() { SortedSet ret = new TreeSet<>(NodeWithContextComparator.reverse()); - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - for (Node node : transientNodes.values()) { + for (Node node : this.transientNodes.values()) { ret.add(ImmutableLocalizedNode.of(node, getObjectName())); } } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } - nodesLock.lock(); + this.nodesLock.lock(); try { - for (Node node : nodes.values()) { + for (Node node : this.nodes.values()) { ret.add(ImmutableLocalizedNode.of(node, getObjectName())); } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } return ret; @@ -433,15 +445,15 @@ public abstract class PermissionHolder { } public > C filterEnduringNodes(C ret, ContextSet filter) { - nodesLock.lock(); + this.nodesLock.lock(); try { - for (Map.Entry> e : nodes.asMap().entrySet()) { + for (Map.Entry> e : this.nodes.asMap().entrySet()) { if (e.getKey().isSatisfiedBy(filter)) { ret.addAll(e.getValue()); } } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } return ret; @@ -452,15 +464,15 @@ public abstract class PermissionHolder { } public > C filterTransientNodes(C ret, ContextSet filter) { - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - for (Map.Entry> e : transientNodes.asMap().entrySet()) { + for (Map.Entry> e : this.transientNodes.asMap().entrySet()) { if (e.getKey().isSatisfiedBy(filter)) { ret.addAll(e.getValue()); } } } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } return ret; @@ -471,26 +483,26 @@ public abstract class PermissionHolder { } public > C filterNodes(C ret, ContextSet filter) { - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - for (Map.Entry> e : transientNodes.asMap().entrySet()) { + for (Map.Entry> e : this.transientNodes.asMap().entrySet()) { if (e.getKey().isSatisfiedBy(filter)) { ret.addAll(e.getValue()); } } } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } - nodesLock.lock(); + this.nodesLock.lock(); try { - for (Map.Entry> e : nodes.asMap().entrySet()) { + for (Map.Entry> e : this.nodes.asMap().entrySet()) { if (e.getKey().isSatisfiedBy(filter)) { ret.addAll(e.getValue()); } } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } return ret; @@ -500,11 +512,11 @@ public abstract class PermissionHolder { boolean result; ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - result = nodes.values().removeIf(predicate); + result = this.nodes.values().removeIf(predicate); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } if (!result) { @@ -514,18 +526,18 @@ public abstract class PermissionHolder { invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean removeIfTransient(Predicate predicate) { boolean result; - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - result = transientNodes.values().removeIf(predicate); + result = this.transientNodes.values().removeIf(predicate); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } if (result) { @@ -576,14 +588,14 @@ public abstract class PermissionHolder { continue; } - Group g = plugin.getGroupManager().getIfLoaded(groupName); + Group g = this.plugin.getGroupManager().getIfLoaded(groupName); if (g != null) { resolvedGroups.add(g); } } // sort the groups according to weight + other factors. - resolvedGroups.sort(inheritanceComparator); + resolvedGroups.sort(this.inheritanceComparator); for (Group g : resolvedGroups) { g.resolveInheritances(accumulator, excludedGroups, context); @@ -648,14 +660,14 @@ public abstract class PermissionHolder { if (!processedGroups.add(groupName) || excludedGroups.contains(groupName) || !n.getValuePrimitive()) continue; - Group g = plugin.getGroupManager().getIfLoaded(groupName); + Group g = this.plugin.getGroupManager().getIfLoaded(groupName); if (g != null) { resolvedGroups.add(g); } } // sort the groups according to weight + other factors. - resolvedGroups.sort(inheritanceComparator); + resolvedGroups.sort(this.inheritanceComparator); for (Group g : resolvedGroups) { g.resolveInheritances(accumulator, excludedGroups); @@ -729,7 +741,7 @@ public abstract class PermissionHolder { } Map perms = new HashMap<>(); - boolean applyShorthand = plugin.getConfiguration().get(ConfigKeys.APPLYING_SHORTHAND); + boolean applyShorthand = this.plugin.getConfiguration().get(ConfigKeys.APPLYING_SHORTHAND); for (Node node : entries) { String perm = lowerCase ? node.getPermission().toLowerCase() : node.getPermission(); @@ -750,7 +762,7 @@ public abstract class PermissionHolder { List entries = resolveInheritances(); Map perms = new HashMap<>(); - boolean applyShorthand = plugin.getConfiguration().get(ConfigKeys.APPLYING_SHORTHAND); + boolean applyShorthand = this.plugin.getConfiguration().get(ConfigKeys.APPLYING_SHORTHAND); for (Node node : entries) { String perm = lowerCase ? node.getPermission().toLowerCase().intern() : node.getPermission(); @@ -769,7 +781,7 @@ public abstract class PermissionHolder { public MetaAccumulator accumulateMeta(MetaAccumulator accumulator, Set excludedGroups, Contexts context) { if (accumulator == null) { - accumulator = MetaAccumulator.makeFromConfig(plugin); + accumulator = MetaAccumulator.makeFromConfig(this.plugin); } if (excludedGroups == null) { @@ -813,14 +825,14 @@ public abstract class PermissionHolder { continue; } - Group g = plugin.getGroupManager().getIfLoaded(groupName); + Group g = this.plugin.getGroupManager().getIfLoaded(groupName); if (g != null) { resolvedGroups.add(g); } } // sort the groups according to weight + other factors. - resolvedGroups.sort(inheritanceComparator); + resolvedGroups.sort(this.inheritanceComparator); for (Group g : resolvedGroups) { g.accumulateMeta(accumulator, excludedGroups, context); @@ -831,7 +843,7 @@ public abstract class PermissionHolder { public MetaAccumulator accumulateMeta(MetaAccumulator accumulator, Set excludedGroups) { if (accumulator == null) { - accumulator = MetaAccumulator.makeFromConfig(plugin); + accumulator = MetaAccumulator.makeFromConfig(this.plugin); } if (excludedGroups == null) { @@ -867,14 +879,14 @@ public abstract class PermissionHolder { if (!processedGroups.add(groupName) || excludedGroups.contains(groupName) || !n.getValuePrimitive()) continue; - Group g = plugin.getGroupManager().getIfLoaded(groupName); + Group g = this.plugin.getGroupManager().getIfLoaded(groupName); if (g != null) { resolvedGroups.add(g); } } // sort the groups according to weight + other factors. - resolvedGroups.sort(inheritanceComparator); + resolvedGroups.sort(this.inheritanceComparator); for (Group g : resolvedGroups) { g.accumulateMeta(accumulator, excludedGroups); @@ -894,9 +906,9 @@ public abstract class PermissionHolder { ImmutableSet before = ImmutableSet.copyOf(getOwnNodesSet()); - nodesLock.lock(); + this.nodesLock.lock(); try { - Iterator it = nodes.values().iterator(); + Iterator it = this.nodes.values().iterator(); while (it.hasNext()) { Node entry = it.next(); if (entry.hasExpired()) { @@ -906,7 +918,7 @@ public abstract class PermissionHolder { } } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } if (work) { @@ -914,9 +926,9 @@ public abstract class PermissionHolder { work = false; } - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - Iterator it = transientNodes.values().iterator(); + Iterator it = this.transientNodes.values().iterator(); while (it.hasNext()) { Node entry = it.next(); if (entry.hasExpired()) { @@ -926,7 +938,7 @@ public abstract class PermissionHolder { } } } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } if (work) { @@ -940,7 +952,7 @@ public abstract class PermissionHolder { ImmutableSet after = ImmutableSet.copyOf(getOwnNodesSet()); for (Node r : removed) { - plugin.getEventFactory().handleNodeRemove(r, this, before, after); + this.plugin.getEventFactory().handleNodeRemove(r, this, before, after); } return true; @@ -1013,17 +1025,17 @@ public abstract class PermissionHolder { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.put(node.getFullContexts().makeImmutable(), node); + this.nodes.put(node.getFullContexts().makeImmutable(), node); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeAdd(node, this, before, after); + this.plugin.getEventFactory().handleNodeAdd(node, this, before, after); return DataMutateResult.SUCCESS; } @@ -1050,17 +1062,17 @@ public abstract class PermissionHolder { ImmutableCollection before = getEnduringNodes().values(); // Remove the old node & add the new one. - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.remove(previous.getFullContexts().makeImmutable(), previous); - nodes.put(newNode.getFullContexts().makeImmutable(), newNode); + this.nodes.remove(previous.getFullContexts().makeImmutable(), previous); + this.nodes.put(newNode.getFullContexts().makeImmutable(), newNode); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeAdd(newNode, this, before, after); + this.plugin.getEventFactory().handleNodeAdd(newNode, this, before, after); return Maps.immutableEntry(DataMutateResult.SUCCESS, newNode); } @@ -1077,17 +1089,17 @@ public abstract class PermissionHolder { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.remove(previous.getFullContexts().makeImmutable(), previous); - nodes.put(node.getFullContexts().makeImmutable(), node); + this.nodes.remove(previous.getFullContexts().makeImmutable(), previous); + this.nodes.put(node.getFullContexts().makeImmutable(), node); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeAdd(node, this, before, after); + this.plugin.getEventFactory().handleNodeAdd(node, this, before, after); return Maps.immutableEntry(DataMutateResult.SUCCESS, node); } } @@ -1112,18 +1124,18 @@ public abstract class PermissionHolder { ImmutableCollection before = getTransientNodes().values(); - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - transientNodes.put(node.getFullContexts().makeImmutable(), node); + this.transientNodes.put(node.getFullContexts().makeImmutable(), node); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getTransientNodes().values(); - plugin.getEventFactory().handleNodeAdd(node, this, before, after); + this.plugin.getEventFactory().handleNodeAdd(node, this, before, after); return DataMutateResult.SUCCESS; } @@ -1139,17 +1151,17 @@ public abstract class PermissionHolder { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.get(node.getFullContexts().makeImmutable()).removeIf(e -> e.almostEquals(node)); + this.nodes.get(node.getFullContexts().makeImmutable()).removeIf(e -> e.almostEquals(node)); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeRemove(node, this, before, after); + this.plugin.getEventFactory().handleNodeRemove(node, this, before, after); return DataMutateResult.SUCCESS; } @@ -1165,17 +1177,17 @@ public abstract class PermissionHolder { ImmutableCollection before = getTransientNodes().values(); - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - transientNodes.get(node.getFullContexts().makeImmutable()).removeIf(e -> e.almostEquals(node)); + this.transientNodes.get(node.getFullContexts().makeImmutable()).removeIf(e -> e.almostEquals(node)); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getTransientNodes().values(); - plugin.getEventFactory().handleNodeRemove(node, this, before, after); + this.plugin.getEventFactory().handleNodeRemove(node, this, before, after); return DataMutateResult.SUCCESS; } @@ -1193,11 +1205,11 @@ public abstract class PermissionHolder { public boolean clearNodes() { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.clear(); + this.nodes.clear(); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); @@ -1207,17 +1219,17 @@ public abstract class PermissionHolder { return false; } - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearNodes(ContextSet contextSet) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - nodes.removeAll(contextSet.makeImmutable()); + this.nodes.removeAll(contextSet.makeImmutable()); } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); @@ -1227,37 +1239,37 @@ public abstract class PermissionHolder { return false; } - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearParents(boolean giveDefault) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - boolean b = nodes.values().removeIf(Node::isGroupNode); + boolean b = this.nodes.values().removeIf(Node::isGroupNode); if (!b) { return false; } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } if (this.getType().isUser() && giveDefault) { - plugin.getUserManager().giveDefaultIfNeeded((User) this, false); + this.plugin.getUserManager().giveDefaultIfNeeded((User) this, false); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearParents(ContextSet contextSet, boolean giveDefault) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { SortedSet nodes = this.nodes.get(contextSet.makeImmutable()); if (nodes == null) { @@ -1269,40 +1281,40 @@ public abstract class PermissionHolder { return false; } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } if (this.getType().isUser() && giveDefault) { - plugin.getUserManager().giveDefaultIfNeeded((User) this, false); + this.plugin.getUserManager().giveDefaultIfNeeded((User) this, false); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearMeta(MetaType type) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { - if (!nodes.values().removeIf(type::matches)) { + if (!this.nodes.values().removeIf(type::matches)) { return false; } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearMeta(MetaType type, ContextSet contextSet) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { SortedSet nodes = this.nodes.get(contextSet.makeImmutable()); if (nodes == null) { @@ -1314,38 +1326,38 @@ public abstract class PermissionHolder { return false; } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearMetaKeys(String key, boolean temp) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { boolean b = this.nodes.values().removeIf(n -> n.isMeta() && (n.isTemporary() == temp) && n.getMeta().getKey().equalsIgnoreCase(key)); if (!b) { return false; } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearMetaKeys(String key, ContextSet contextSet, boolean temp) { ImmutableCollection before = getEnduringNodes().values(); - nodesLock.lock(); + this.nodesLock.lock(); try { SortedSet nodes = this.nodes.get(contextSet.makeImmutable()); if (nodes == null) { @@ -1357,23 +1369,23 @@ public abstract class PermissionHolder { return false; } } finally { - nodesLock.unlock(); + this.nodesLock.unlock(); } invalidateCache(); ImmutableCollection after = getEnduringNodes().values(); - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public boolean clearTransientNodes() { ImmutableCollection before = getTransientNodes().values(); - transientNodesLock.lock(); + this.transientNodesLock.lock(); try { - transientNodes.clear(); + this.transientNodes.clear(); } finally { - transientNodesLock.unlock(); + this.transientNodesLock.unlock(); } invalidateCache(); @@ -1383,12 +1395,12 @@ public abstract class PermissionHolder { return false; } - plugin.getEventFactory().handleNodeClear(this, before, after); + this.plugin.getEventFactory().handleNodeClear(this, before, after); return true; } public OptionalInt getWeight() { - return weightCache.get(); + return this.weightCache.get(); } private OptionalInt calculateWeight() { @@ -1410,7 +1422,7 @@ public abstract class PermissionHolder { OptionalInt weight = seen ? OptionalInt.of(best) : OptionalInt.empty(); if (!weight.isPresent()) { - Integer w = plugin.getConfiguration().get(ConfigKeys.GROUP_WEIGHTS).get(getObjectName().toLowerCase()); + Integer w = this.plugin.getConfiguration().get(ConfigKeys.GROUP_WEIGHTS).get(getObjectName().toLowerCase()); if (w != null) { weight = OptionalInt.of(w); } diff --git a/common/src/main/java/me/lucko/luckperms/common/model/Track.java b/common/src/main/java/me/lucko/luckperms/common/model/Track.java index 08db2b0ea..6ff6f2c1a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/model/Track.java +++ b/common/src/main/java/me/lucko/luckperms/common/model/Track.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.common.model; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.DataMutateResult; @@ -43,20 +38,15 @@ import java.util.List; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; -@ToString -@EqualsAndHashCode(of = {"name"}) -@RequiredArgsConstructor -public class Track implements Identifiable { +public final class Track implements Identifiable { /** * The name of the track */ - @Getter private final String name; private final LuckPermsPlugin plugin; - @Getter private final Lock ioLock = new ReentrantLock(); /** @@ -64,12 +54,28 @@ public class Track implements Identifiable { */ private final List groups = Collections.synchronizedList(new ArrayList<>()); - @Getter private final ApiTrack delegate = new ApiTrack(this); + public Track(String name, LuckPermsPlugin plugin) { + this.name = name; + this.plugin = plugin; + } + + public String getName() { + return this.name; + } + + public Lock getIoLock() { + return this.ioLock; + } + + public ApiTrack getDelegate() { + return this.delegate; + } + @Override public String getId() { - return name.toLowerCase(); + return this.name.toLowerCase(); } /** @@ -78,7 +84,7 @@ public class Track implements Identifiable { * @return am ordered {@link List} of the groups on this track */ public List getGroups() { - return ImmutableList.copyOf(groups); + return ImmutableList.copyOf(this.groups); } public void setGroups(List groups) { @@ -92,7 +98,7 @@ public class Track implements Identifiable { * @return the number of groups on this track */ public int getSize() { - return groups.size(); + return this.groups.size(); } /** @@ -129,11 +135,11 @@ public class Track implements Identifiable { throw new IllegalArgumentException(); } - if (groups.indexOf(current) == groups.size() - 1) { + if (this.groups.indexOf(current) == this.groups.size() - 1) { return null; } - return groups.get(groups.indexOf(current) + 1); + return this.groups.get(this.groups.indexOf(current) + 1); } /** @@ -148,11 +154,11 @@ public class Track implements Identifiable { throw new IllegalArgumentException(); } - if (groups.indexOf(current) == 0) { + if (this.groups.indexOf(current) == 0) { return null; } - return groups.get(groups.indexOf(current) - 1); + return this.groups.get(this.groups.indexOf(current) - 1); } /** @@ -166,11 +172,11 @@ public class Track implements Identifiable { return DataMutateResult.ALREADY_HAS; } - List before = ImmutableList.copyOf(groups); - groups.add(group.getName()); - List after = ImmutableList.copyOf(groups); + List before = ImmutableList.copyOf(this.groups); + this.groups.add(group.getName()); + List after = ImmutableList.copyOf(this.groups); - plugin.getEventFactory().handleTrackAddGroup(this, group.getName(), before, after); + this.plugin.getEventFactory().handleTrackAddGroup(this, group.getName(), before, after); return DataMutateResult.SUCCESS; } @@ -187,11 +193,11 @@ public class Track implements Identifiable { return DataMutateResult.ALREADY_HAS; } - List before = ImmutableList.copyOf(groups); - groups.add(position, group.getName()); - List after = ImmutableList.copyOf(groups); + List before = ImmutableList.copyOf(this.groups); + this.groups.add(position, group.getName()); + List after = ImmutableList.copyOf(this.groups); - plugin.getEventFactory().handleTrackAddGroup(this, group.getName(), before, after); + this.plugin.getEventFactory().handleTrackAddGroup(this, group.getName(), before, after); return DataMutateResult.SUCCESS; } @@ -216,11 +222,11 @@ public class Track implements Identifiable { return DataMutateResult.LACKS; } - List before = ImmutableList.copyOf(groups); - groups.remove(group); - List after = ImmutableList.copyOf(groups); + List before = ImmutableList.copyOf(this.groups); + this.groups.remove(group); + List after = ImmutableList.copyOf(this.groups); - plugin.getEventFactory().handleTrackRemoveGroup(this, group, before, after); + this.plugin.getEventFactory().handleTrackRemoveGroup(this, group, before, after); return DataMutateResult.SUCCESS; } @@ -241,15 +247,34 @@ public class Track implements Identifiable { * @return true if the group is on this track */ public boolean containsGroup(String group) { - return groups.contains(group); + return this.groups.contains(group); } /** * Clear all of the groups within this track */ public void clearGroups() { - List before = ImmutableList.copyOf(groups); - groups.clear(); - plugin.getEventFactory().handleTrackClear(this, before); + List before = ImmutableList.copyOf(this.groups); + this.groups.clear(); + this.plugin.getEventFactory().handleTrackClear(this, before); } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof Track)) return false; + final Track other = (Track) o; + return this.name.equals(other.name); + } + + @Override + public int hashCode() { + return this.name.hashCode(); + } + + @Override + public String toString() { + return "Track(name=" + this.name + ", groups=" + this.getGroups() + ")"; + } + } diff --git a/common/src/main/java/me/lucko/luckperms/common/model/User.java b/common/src/main/java/me/lucko/luckperms/common/model/User.java index 74e4e8d23..a6cc82cc3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/model/User.java +++ b/common/src/main/java/me/lucko/luckperms/common/model/User.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.model; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.common.api.delegates.model.ApiUser; import me.lucko.luckperms.common.buffers.BufferedRequest; @@ -45,14 +41,11 @@ import java.util.Optional; import java.util.UUID; import java.util.concurrent.CompletableFuture; -@ToString(of = {"uuid"}) -@EqualsAndHashCode(of = {"uuid"}, callSuper = false) public class User extends PermissionHolder implements Identifiable { /** * The users Mojang UUID */ - @Getter private final UUID uuid; /** @@ -63,19 +56,15 @@ public class User extends PermissionHolder implements Identifiable refreshBuffer; - @Getter private final ApiUser delegate = new ApiUser(this); public User(UUID uuid, LuckPermsPlugin plugin) { @@ -86,7 +75,7 @@ public class User extends PermissionHolder implements Identifiable getRefreshBuffer() { + return this.refreshBuffer; + } + + @Override + public ApiUser getDelegate() { + return this.delegate; } @Override public UserIdentifier getId() { - return UserIdentifier.of(uuid, name); + return UserIdentifier.of(this.uuid, this.name); } public Optional getName() { - return Optional.ofNullable(name); + return Optional.ofNullable(this.name); } /** @@ -161,7 +173,7 @@ public class User extends PermissionHolder implements Identifiable reloadCachedData() { return CompletableFuture.allOf( - cachedData.reloadPermissions(), - cachedData.reloadMeta() - ).thenAccept(n -> getPlugin().getEventFactory().handleUserDataRecalculate(this, cachedData)); + this.cachedData.reloadPermissions(), + this.cachedData.reloadMeta() + ).thenAccept(n -> getPlugin().getEventFactory().handleUserDataRecalculate(this, this.cachedData)); } /** @@ -216,6 +228,24 @@ public class User extends PermissionHolder implements Identifiable { private final User user; @@ -226,7 +256,7 @@ public class User extends PermissionHolder implements Identifiable getServer() { + return this.node.getServer(); + } + + @Override + public boolean getValuePrimitive() { + return this.node.getValuePrimitive(); + } + + @Override + public String getKey() { + return this.node.getKey(); + } + + @Nonnull + @Override + public Map.Entry getMeta() throws IllegalStateException { + return this.node.getMeta(); + } + + @Override + public boolean isServerSpecific() { + return this.node.isServerSpecific(); + } + + @Nonnull + @Override + public Tristate getTristate() { + return this.node.getTristate(); + } + + @Override + public boolean hasExpired() { + return this.node.hasExpired(); + } + + @Override + public boolean isWildcard() { + return this.node.isWildcard(); + } + + @Override + public boolean equalsIgnoringValueOrTemp(@Nonnull Node other) { + return this.node.equalsIgnoringValueOrTemp(other); + } + + @Nonnull + @Override + public List resolveShorthand() { + return this.node.resolveShorthand(); + } + + @Override + public boolean almostEquals(@Nonnull Node other) { + return this.node.almostEquals(other); + } + + @Nonnull + @Override + public ContextSet getFullContexts() { + return this.node.getFullContexts(); + } + + @Override + public long getSecondsTilExpiry() throws IllegalStateException { + return this.node.getSecondsTilExpiry(); + } + + @Nonnull + @Override + public String getPermission() { + return this.node.getPermission(); + } + + @Nonnull + @Override + public Map.Entry getSuffix() throws IllegalStateException { + return this.node.getSuffix(); + } + + @Override + public boolean isWorldSpecific() { + return this.node.isWorldSpecific(); + } + + @Override + public boolean equalsIgnoringValue(@Nonnull Node other) { + return this.node.equalsIgnoringValue(other); + } + + @Override + public long getExpiryUnixTime() throws IllegalStateException { + return this.node.getExpiryUnixTime(); + } + + @Override + public boolean isGroupNode() { + return this.node.isGroupNode(); + } + + @Override + public Boolean setValue(Boolean value) { + return this.node.setValue(value); + } + + @Override + public boolean isPrefix() { + return this.node.isPrefix(); + } + + @Nonnull + @Override + public String getGroupName() throws IllegalStateException { + return this.node.getGroupName(); + } + + @Nonnull + @Override + public Date getExpiry() throws IllegalStateException { + return this.node.getExpiry(); + } + + @Override + public boolean isNegated() { + return this.node.isNegated(); + } + + @Override + public boolean hasSpecificContext() { + return this.node.hasSpecificContext(); + } + + @Override + public int getWildcardLevel() throws IllegalStateException { + return this.node.getWildcardLevel(); + } + + @Override + public boolean isTemporary() { + return this.node.isTemporary(); + } + + @Nonnull + @Override + public Map.Entry getPrefix() throws IllegalStateException { + return this.node.getPrefix(); + } + + @Override + public boolean isMeta() { + return this.node.isMeta(); + } + + @Override + public boolean isPermanent() { + return this.node.isPermanent(); + } + + @Nonnull + @Override + public Optional getWorld() { + return this.node.getWorld(); + } + + @Nonnull + @Override + public Boolean getValue() { + return this.node.getValue(); + } + + @Override + public boolean isOverride() { + return this.node.isOverride(); + } + + @Override + public boolean isSuffix() { + return this.node.isSuffix(); + } + + @Nonnull + @Override + public ContextSet getContexts() { + return this.node.getContexts(); + } + + @Override + public boolean appliesGlobally() { + return this.node.appliesGlobally(); + } + + @Override + public boolean shouldApplyWithContext(@Nonnull ContextSet context) { + return this.node.shouldApplyWithContext(context); + } + + @Override + public String toString() { + return "ImmutableLocalizedNode(node=" + this.getNode() + ", location=" + this.getLocation() + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/ImmutableNode.java b/common/src/main/java/me/lucko/luckperms/common/node/ImmutableNode.java index 2f472a474..f390cc191 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/ImmutableNode.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/ImmutableNode.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.Getter; -import lombok.ToString; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.Contexts; @@ -43,12 +40,13 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import javax.annotation.Nonnull; + import static com.google.common.base.Preconditions.checkState; /** * An immutable implementation of {@link Node}. */ -@ToString(of = {"permission", "value", "override", "server", "world", "expireAt", "contexts"}) public final class ImmutableNode implements Node { /** @@ -57,12 +55,10 @@ public final class ImmutableNode implements Node { public static final char NODE_SEPARATOR = '.'; public static final int NODE_SEPARATOR_CODE = Character.getNumericValue('.'); - @Getter private final String permission; private final boolean value; - @Getter private boolean override; // nullable @@ -73,10 +69,8 @@ public final class ImmutableNode implements Node { // 0L for no expiry private final long expireAt; - @Getter private final ImmutableContextSet contexts; - @Getter private final ImmutableContextSet fullContexts; /* @@ -140,14 +134,14 @@ public final class ImmutableNode implements Node { this.contexts = contexts == null ? ContextSet.empty() : contexts.makeImmutable(); // define cached state - groupName = NodeFactory.parseGroupNode(this.permission); - wildcardLevel = this.permission.endsWith(WildcardProcessor.WILDCARD_SUFFIX) ? this.permission.chars().filter(num -> num == NODE_SEPARATOR_CODE).sum() : -1; - meta = NodeFactory.parseMetaNode(this.permission); - prefix = NodeFactory.parsePrefixNode(this.permission); - suffix = NodeFactory.parseSuffixNode(this.permission); - resolvedShorthand = ImmutableList.copyOf(ShorthandParser.parseShorthand(getPermission())); - optServer = Optional.ofNullable(this.server); - optWorld = Optional.ofNullable(this.world); + this.groupName = NodeFactory.parseGroupNode(this.permission); + this.wildcardLevel = this.permission.endsWith(WildcardProcessor.WILDCARD_SUFFIX) ? this.permission.chars().filter(num -> num == NODE_SEPARATOR_CODE).sum() : -1; + this.meta = NodeFactory.parseMetaNode(this.permission); + this.prefix = NodeFactory.parsePrefixNode(this.permission); + this.suffix = NodeFactory.parseSuffixNode(this.permission); + this.resolvedShorthand = ImmutableList.copyOf(ShorthandParser.parseShorthand(getPermission())); + this.optServer = Optional.ofNullable(this.server); + this.optWorld = Optional.ofNullable(this.world); // calculate the "full" context set if (this.server != null || this.world != null) { @@ -167,132 +161,163 @@ public final class ImmutableNode implements Node { this.hashCode = calculateHashCode(); } + @Nonnull + @Override + public String getPermission() { + return this.permission; + } + @Override public boolean getValuePrimitive() { - return value; + return this.value; } + @Override + public boolean isOverride() { + return this.override; + } + + @Nonnull @Override public Optional getServer() { - return optServer; + return this.optServer; } + @Nonnull @Override public Optional getWorld() { - return optWorld; + return this.optWorld; } @Override public boolean isServerSpecific() { - return server != null; + return this.server != null; } @Override public boolean isWorldSpecific() { - return world != null; + return this.world != null; + } + + @Nonnull + @Override + public ImmutableContextSet getContexts() { + return this.contexts; + } + + @Nonnull + @Override + public ImmutableContextSet getFullContexts() { + return this.fullContexts; } @Override public boolean appliesGlobally() { - return server == null && world == null && contexts.isEmpty(); + return this.server == null && this.world == null && this.contexts.isEmpty(); } @Override public boolean hasSpecificContext() { - return server != null || world != null || !contexts.isEmpty(); + return this.server != null || this.world != null || !this.contexts.isEmpty(); } @Override public boolean isTemporary() { - return expireAt != 0L; + return this.expireAt != 0L; } @Override public long getExpiryUnixTime() { checkState(isTemporary(), "Node does not have an expiry time."); - return expireAt; + return this.expireAt; } + @Nonnull @Override public Date getExpiry() { checkState(isTemporary(), "Node does not have an expiry time."); - return new Date(expireAt * 1000L); + return new Date(this.expireAt * 1000L); } @Override public long getSecondsTilExpiry() { checkState(isTemporary(), "Node does not have an expiry time."); - return expireAt - DateUtil.unixSecondsNow(); + return this.expireAt - DateUtil.unixSecondsNow(); } @Override public boolean hasExpired() { - return isTemporary() && expireAt < DateUtil.unixSecondsNow(); + return isTemporary() && this.expireAt < DateUtil.unixSecondsNow(); } @Override public boolean isGroupNode() { - return groupName != null; + return this.groupName != null; } + @Nonnull @Override public String getGroupName() { checkState(isGroupNode(), "Node is not a group node"); - return groupName; + return this.groupName; } @Override public boolean isWildcard() { - return wildcardLevel != -1; + return this.wildcardLevel != -1; } @Override public int getWildcardLevel() { checkState(isWildcard(), "Node is not a wildcard"); - return wildcardLevel; + return this.wildcardLevel; } @Override public boolean isMeta() { - return meta != null; + return this.meta != null; } + @Nonnull @Override public Map.Entry getMeta() { checkState(isMeta(), "Node is not a meta node"); - return meta; + return this.meta; } @Override public boolean isPrefix() { - return prefix != null; + return this.prefix != null; } + @Nonnull @Override public Map.Entry getPrefix() { checkState(isPrefix(), "Node is not a prefix node"); - return prefix; + return this.prefix; } @Override public boolean isSuffix() { - return suffix != null; + return this.suffix != null; } + @Nonnull @Override public Map.Entry getSuffix() { checkState(isSuffix(), "Node is not a suffix node"); - return suffix; + return this.suffix; } @Override - public boolean shouldApplyWithContext(ContextSet context) { + public boolean shouldApplyWithContext(@Nonnull ContextSet context) { return getFullContexts().isSatisfiedBy(context, false); } + @Nonnull @Override public List resolveShorthand() { - return resolvedShorthand; + return this.resolvedShorthand; } @SuppressWarnings("StringEquality") @@ -326,7 +351,6 @@ public final class ImmutableNode implements Node { private int calculateHashCode() { final int PRIME = 59; int result = 1; - result = result * PRIME + this.permission.hashCode(); result = result * PRIME + (this.value ? 79 : 97); result = result * PRIME + (this.override ? 79 : 97); @@ -334,13 +358,12 @@ public final class ImmutableNode implements Node { result = result * PRIME + (this.world == null ? 43 : this.world.hashCode()); result = result * PRIME + (int) (this.expireAt >>> 32 ^ this.expireAt); result = result * PRIME + this.contexts.hashCode(); - return result; } @SuppressWarnings("StringEquality") @Override - public boolean equalsIgnoringValue(Node other) { + public boolean equalsIgnoringValue(@Nonnull Node other) { if (this.permission != other.getPermission()) return false; if (this.override != other.isOverride()) return false; @@ -358,7 +381,7 @@ public final class ImmutableNode implements Node { @SuppressWarnings("StringEquality") @Override - public boolean almostEquals(Node other) { + public boolean almostEquals(@Nonnull Node other) { if (this.permission != other.getPermission()) return false; if (this.override != other.isOverride()) return false; @@ -377,7 +400,7 @@ public final class ImmutableNode implements Node { @SuppressWarnings("StringEquality") @Override - public boolean equalsIgnoringValueOrTemp(Node other) { + public boolean equalsIgnoringValueOrTemp(@Nonnull Node other) { if (this.permission != other.getPermission()) return false; if (this.override != other.isOverride()) return false; @@ -418,4 +441,8 @@ public final class ImmutableNode implements Node { return s; } + @Override + public String toString() { + return "ImmutableNode(permission=" + this.permission + ", value=" + this.value + ", override=" + this.override + ", server=" + this.getServer() + ", world=" + this.getWorld() + ", expireAt=" + this.expireAt + ", contexts=" + this.contexts + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/ImmutableTransientNode.java b/common/src/main/java/me/lucko/luckperms/common/node/ImmutableTransientNode.java index 0c9d7ba6b..bfe72ffc9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/ImmutableTransientNode.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/ImmutableTransientNode.java @@ -25,37 +25,254 @@ package me.lucko.luckperms.common.node; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.NonNull; -import lombok.ToString; -import lombok.experimental.Delegate; - import me.lucko.luckperms.api.Node; +import me.lucko.luckperms.api.Tristate; +import me.lucko.luckperms.api.context.ContextSet; + +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; + +import javax.annotation.Nonnull; /** * Holds a Node and plus an owning object. All calls are passed onto the contained Node instance. */ -@Getter -@ToString -@AllArgsConstructor(access = AccessLevel.PRIVATE) public final class ImmutableTransientNode implements Node { - public static ImmutableTransientNode of(@NonNull Node node, @NonNull Object owner) { + public static ImmutableTransientNode of(Node node, Object owner) { + Objects.requireNonNull(node, "node"); + Objects.requireNonNull(owner, "owner"); return new ImmutableTransientNode(node, owner); } - @Delegate private final Node node; private final Object owner; + private ImmutableTransientNode(Node node, Object owner) { + this.node = node; + this.owner = owner; + } + @Override public int hashCode() { - return node.hashCode(); + return this.node.hashCode(); } @Override public boolean equals(Object obj) { - return this == obj || node.equals(obj); + return this == obj || this.node.equals(obj); + } + + public Node getNode() { + return this.node; + } + + public Object getOwner() { + return this.owner; + } + + @Nonnull + @Override + public Optional getServer() { + return this.node.getServer(); + } + + @Override + public boolean getValuePrimitive() { + return this.node.getValuePrimitive(); + } + + @Override + public String getKey() { + return this.node.getKey(); + } + + @Nonnull + @Override + public Map.Entry getMeta() throws IllegalStateException { + return this.node.getMeta(); + } + + @Override + public boolean isServerSpecific() { + return this.node.isServerSpecific(); + } + + @Nonnull + @Override + public Tristate getTristate() { + return this.node.getTristate(); + } + + @Override + public boolean hasExpired() { + return this.node.hasExpired(); + } + + @Override + public boolean isWildcard() { + return this.node.isWildcard(); + } + + @Override + public boolean equalsIgnoringValueOrTemp(@Nonnull Node other) { + return this.node.equalsIgnoringValueOrTemp(other); + } + + @Nonnull + @Override + public List resolveShorthand() { + return this.node.resolveShorthand(); + } + + @Override + public boolean almostEquals(@Nonnull Node other) { + return this.node.almostEquals(other); + } + + @Nonnull + @Override + public ContextSet getFullContexts() { + return this.node.getFullContexts(); + } + + @Override + public long getSecondsTilExpiry() throws IllegalStateException { + return this.node.getSecondsTilExpiry(); + } + + @Nonnull + @Override + public String getPermission() { + return this.node.getPermission(); + } + + @Nonnull + @Override + public Map.Entry getSuffix() throws IllegalStateException { + return this.node.getSuffix(); + } + + @Override + public boolean isWorldSpecific() { + return this.node.isWorldSpecific(); + } + + @Override + public boolean equalsIgnoringValue(@Nonnull Node other) { + return this.node.equalsIgnoringValue(other); + } + + @Override + public long getExpiryUnixTime() throws IllegalStateException { + return this.node.getExpiryUnixTime(); + } + + @Override + public boolean isGroupNode() { + return this.node.isGroupNode(); + } + + @Override + public Boolean setValue(Boolean value) { + return this.node.setValue(value); + } + + @Override + public boolean isPrefix() { + return this.node.isPrefix(); + } + + @Nonnull + @Override + public String getGroupName() throws IllegalStateException { + return this.node.getGroupName(); + } + + @Nonnull + @Override + public Date getExpiry() throws IllegalStateException { + return this.node.getExpiry(); + } + + @Override + public boolean isNegated() { + return this.node.isNegated(); + } + + @Override + public boolean hasSpecificContext() { + return this.node.hasSpecificContext(); + } + + @Override + public int getWildcardLevel() throws IllegalStateException { + return this.node.getWildcardLevel(); + } + + @Override + public boolean isTemporary() { + return this.node.isTemporary(); + } + + @Nonnull + @Override + public Map.Entry getPrefix() throws IllegalStateException { + return this.node.getPrefix(); + } + + @Override + public boolean isMeta() { + return this.node.isMeta(); + } + + @Override + public boolean isPermanent() { + return this.node.isPermanent(); + } + + @Nonnull + @Override + public Optional getWorld() { + return this.node.getWorld(); + } + + @Nonnull + @Override + public Boolean getValue() { + return this.node.getValue(); + } + + @Override + public boolean isOverride() { + return this.node.isOverride(); + } + + @Override + public boolean isSuffix() { + return this.node.isSuffix(); + } + + @Nonnull + @Override + public ContextSet getContexts() { + return this.node.getContexts(); + } + + @Override + public boolean appliesGlobally() { + return this.node.appliesGlobally(); + } + + @Override + public boolean shouldApplyWithContext(@Nonnull ContextSet context) { + return this.node.shouldApplyWithContext(context); + } + + @Override + public String toString() { + return "ImmutableTransientNode(node=" + this.getNode() + ", owner=" + this.getOwner() + ")"; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/InheritanceInfo.java b/common/src/main/java/me/lucko/luckperms/common/node/InheritanceInfo.java index d7307b683..2463fa223 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/InheritanceInfo.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/InheritanceInfo.java @@ -25,26 +25,18 @@ package me.lucko.luckperms.common.node; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.NonNull; -import lombok.ToString; - import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.Tristate; +import java.util.Objects; import java.util.Optional; /** * The result of an inheritance lookup */ -@ToString -@EqualsAndHashCode -@AllArgsConstructor(access = AccessLevel.PRIVATE) public final class InheritanceInfo { - public static InheritanceInfo of(@NonNull LocalizedNode node) { + public static InheritanceInfo of(LocalizedNode node) { + Objects.requireNonNull(node, "node"); return new InheritanceInfo(node.getTristate(), node.getLocation()); } @@ -52,12 +44,41 @@ public final class InheritanceInfo { return new InheritanceInfo(Tristate.UNDEFINED, null); } - @Getter private final Tristate result; private final String location; - public Optional getLocation() { - return Optional.ofNullable(location); + private InheritanceInfo(Tristate result, String location) { + this.result = result; + this.location = location; } + public Optional getLocation() { + return Optional.ofNullable(this.location); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof InheritanceInfo)) return false; + final InheritanceInfo other = (InheritanceInfo) o; + return this.result == other.result && this.getLocation().equals(other.getLocation()); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.result.hashCode(); + result = result * PRIME + this.getLocation().hashCode(); + return result; + } + + @Override + public String toString() { + return "InheritanceInfo(result=" + this.result + ", location=" + this.getLocation() + ")"; + } + + public Tristate getResult() { + return this.result; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/LegacyNodeFactory.java b/common/src/main/java/me/lucko/luckperms/common/node/LegacyNodeFactory.java index 21b3237b0..a8b223f6d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/LegacyNodeFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/LegacyNodeFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.experimental.UtilityClass; - import com.google.common.base.Splitter; import me.lucko.luckperms.api.Node; @@ -37,8 +35,7 @@ import java.util.List; import java.util.Map; import java.util.regex.Pattern; -@UtilityClass -public class LegacyNodeFactory { +public final class LegacyNodeFactory { /** * The characters which are delimited when serializing a permission string @@ -214,4 +211,6 @@ public class LegacyNodeFactory { } } + private LegacyNodeFactory() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/NodeBuilder.java b/common/src/main/java/me/lucko/luckperms/common/node/NodeBuilder.java index 54fd73d35..10b270242 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/NodeBuilder.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/NodeBuilder.java @@ -25,16 +25,17 @@ package me.lucko.luckperms.common.node; -import lombok.NonNull; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.api.context.ImmutableContextSet; import java.util.Map; +import java.util.Objects; import java.util.Set; +import javax.annotation.Nonnull; + /** * Builds node instances */ @@ -65,44 +66,53 @@ class NodeBuilder implements Node.Builder { this.extraContexts.addAll(other.getContexts()); } + @Nonnull @Override public Node.Builder setNegated(boolean negated) { - value = !negated; + this.value = !negated; return this; } + @Nonnull @Override public Node.Builder setValue(boolean value) { this.value = value; return this; } + @Nonnull @Override public Node.Builder setOverride(boolean override) { this.override = override; return this; } + @Nonnull @Override public Node.Builder setExpiry(long expireAt) { this.expireAt = expireAt; return this; } + @Nonnull @Override public Node.Builder setWorld(String world) { this.world = world; return this; } + @Nonnull @Override public Node.Builder setServer(String server) { this.server = server; return this; } + @Nonnull @Override - public Node.Builder withExtraContext(@NonNull String key, @NonNull String value) { + public Node.Builder withExtraContext(@Nonnull String key, @Nonnull String value) { + Objects.requireNonNull(key, "key"); + Objects.requireNonNull(value, "value"); switch (key.toLowerCase()) { case Contexts.SERVER_KEY: setServer(value); @@ -118,32 +128,41 @@ class NodeBuilder implements Node.Builder { return this; } + @Nonnull @Override - public Node.Builder withExtraContext(Map.Entry entry) { + public Node.Builder withExtraContext(@Nonnull Map.Entry entry) { + Objects.requireNonNull(entry, "entry"); withExtraContext(entry.getKey(), entry.getValue()); return this; } + @Nonnull @Override - public Node.Builder withExtraContext(Map map) { + public Node.Builder withExtraContext(@Nonnull Map map) { + Objects.requireNonNull(map, "map"); withExtraContext(ContextSet.fromMap(map)); return this; } + @Nonnull @Override - public Node.Builder withExtraContext(Set> context) { + public Node.Builder withExtraContext(@Nonnull Set> context) { + Objects.requireNonNull(context, "context"); withExtraContext(ContextSet.fromEntries(context)); return this; } + @Nonnull @Override - public Node.Builder withExtraContext(ContextSet set) { + public Node.Builder withExtraContext(@Nonnull ContextSet set) { + Objects.requireNonNull(set, "set"); set.toSet().forEach(this::withExtraContext); return this; } + @Nonnull @Override public Node build() { - return new ImmutableNode(permission, value, override, expireAt, server, world, extraContexts.build()); + return new ImmutableNode(this.permission, this.value, this.override, this.expireAt, this.server, this.world, this.extraContexts.build()); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/NodeFactory.java b/common/src/main/java/me/lucko/luckperms/common/node/NodeFactory.java index 820f00890..454284673 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/NodeFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/NodeFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.experimental.UtilityClass; - import com.google.common.base.Splitter; import com.google.common.collect.Maps; @@ -43,8 +41,7 @@ import java.util.Map; /** * Utility class to make Node(Builder) instances from strings or existing Nodes */ -@UtilityClass -public class NodeFactory { +public final class NodeFactory { public static final String DEFAULT_GROUP_NAME = "default"; public static final String PREFIX_KEY = "prefix"; @@ -425,4 +422,6 @@ public class NodeFactory { } } + private NodeFactory() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/NodeHeldPermission.java b/common/src/main/java/me/lucko/luckperms/common/node/NodeHeldPermission.java index 17704ee2c..712fb2815 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/NodeHeldPermission.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/NodeHeldPermission.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; - import me.lucko.luckperms.api.HeldPermission; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.context.ContextSet; @@ -36,49 +32,88 @@ import me.lucko.luckperms.api.context.ContextSet; import java.util.Optional; import java.util.OptionalLong; -@Getter -@EqualsAndHashCode -@AllArgsConstructor(staticName = "of") +import javax.annotation.Nonnull; + public final class NodeHeldPermission implements HeldPermission { public static NodeHeldPermission of(T holder, NodeModel nodeModel) { return of(holder, nodeModel.toNode()); } + public static NodeHeldPermission of(T holder, Node node) { + return new NodeHeldPermission<>(holder, node); + } + private final T holder; private final Node node; + private NodeHeldPermission(T holder, Node node) { + this.holder = holder; + this.node = node; + } + + @Nonnull @Override public String getPermission() { - return node.getPermission(); + return this.node.getPermission(); } @Override public boolean getValue() { - return node.getValuePrimitive(); + return this.node.getValuePrimitive(); } + @Nonnull @Override public Optional getServer() { - return node.getServer(); + return this.node.getServer(); } + @Nonnull @Override public Optional getWorld() { - return node.getWorld(); + return this.node.getWorld(); } @Override public OptionalLong getExpiry() { - return node.isTemporary() ? OptionalLong.of(node.getExpiryUnixTime()) : OptionalLong.empty(); + return this.node.isTemporary() ? OptionalLong.of(this.node.getExpiryUnixTime()) : OptionalLong.empty(); } @Override public ContextSet getContexts() { - return node.getContexts(); + return this.node.getContexts(); + } + + @Nonnull + @Override + public Node asNode() { + return this.node; + } + + @Nonnull + @Override + public T getHolder() { + return this.holder; + } + + public Node getNode() { + return this.node; } @Override - public Node asNode() { - return node; + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof NodeHeldPermission)) return false; + final NodeHeldPermission other = (NodeHeldPermission) o; + return this.getHolder().equals(other.getHolder()) && this.getNode().equals(other.getNode()); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.getHolder().hashCode(); + result = result * PRIME + this.getNode().hashCode(); + return result; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/NodeModel.java b/common/src/main/java/me/lucko/luckperms/common/node/NodeModel.java index 960454b23..96791fb10 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/NodeModel.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/NodeModel.java @@ -25,11 +25,11 @@ package me.lucko.luckperms.common.node; -import lombok.NonNull; - import me.lucko.luckperms.api.Node; import me.lucko.luckperms.api.context.ImmutableContextSet; +import java.util.Objects; + /** * An stripped down version of {@link Node}, without methods and cached values * for handling permission lookups. @@ -63,27 +63,27 @@ public final class NodeModel { private final ImmutableContextSet contexts; private Node node = null; - private NodeModel(@NonNull String permission, boolean value, @NonNull String server, @NonNull String world, long expiry, @NonNull ImmutableContextSet contexts) { - this.permission = permission; + private NodeModel(String permission, boolean value, String server, String world, long expiry, ImmutableContextSet contexts) { + this.permission = Objects.requireNonNull(permission, "permission"); this.value = value; - this.server = server; - this.world = world; + this.server = Objects.requireNonNull(server, "server"); + this.world = Objects.requireNonNull(world, "world"); this.expiry = expiry; - this.contexts = contexts; + this.contexts = Objects.requireNonNull(contexts, "contexts"); } public synchronized Node toNode() { - if (node == null) { - node = NodeFactory.builder(permission) - .setValue(value) - .setServer(server) - .setWorld(world) - .setExpiry(expiry) - .withExtraContext(contexts) + if (this.node == null) { + this.node = NodeFactory.builder(this.permission) + .setValue(this.value) + .setServer(this.server) + .setWorld(this.world) + .setExpiry(this.expiry) + .withExtraContext(this.contexts) .build(); } - return node; + return this.node; } public String getPermission() { @@ -111,27 +111,27 @@ public final class NodeModel { } public NodeModel setPermission(String permission) { - return of(permission, value, server, world, expiry, contexts); + return of(permission, this.value, this.server, this.world, this.expiry, this.contexts); } public NodeModel setValue(boolean value) { - return of(permission, value, server, world, expiry, contexts); + return of(this.permission, value, this.server, this.world, this.expiry, this.contexts); } public NodeModel setServer(String server) { - return of(permission, value, server, world, expiry, contexts); + return of(this.permission, this.value, server, this.world, this.expiry, this.contexts); } public NodeModel setWorld(String world) { - return of(permission, value, server, world, expiry, contexts); + return of(this.permission, this.value, this.server, world, this.expiry, this.contexts); } public NodeModel setExpiry(long expiry) { - return of(permission, value, server, world, expiry, contexts); + return of(this.permission, this.value, this.server, this.world, expiry, this.contexts); } public NodeModel setContexts(ImmutableContextSet contexts) { - return of(permission, value, server, world, expiry, contexts); + return of(this.permission, this.value, this.server, this.world, this.expiry, contexts); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/node/NodeTools.java b/common/src/main/java/me/lucko/luckperms/common/node/NodeTools.java index 3ed585060..038bcb6ed 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/NodeTools.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/NodeTools.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.Node; import java.util.ArrayList; @@ -35,8 +33,7 @@ import java.util.Iterator; import java.util.List; import java.util.Set; -@UtilityClass -public class NodeTools { +public final class NodeTools { public static void removeAlmostEqual(Iterator it) { List alreadyIn = new ArrayList<>(); @@ -100,4 +97,6 @@ public class NodeTools { } } } + + private NodeTools() {} } diff --git a/common/src/main/java/me/lucko/luckperms/common/node/NodeWithContextComparator.java b/common/src/main/java/me/lucko/luckperms/common/node/NodeWithContextComparator.java index 1e40ecafa..14c7eeb67 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/NodeWithContextComparator.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/NodeWithContextComparator.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.AccessLevel; -import lombok.NoArgsConstructor; - import me.lucko.luckperms.api.LocalizedNode; import me.lucko.luckperms.api.Node; import me.lucko.luckperms.common.utils.CollationKeyCache; @@ -37,7 +34,6 @@ import java.util.Comparator; /** * Compares permission nodes based upon their supposed "priority". */ -@NoArgsConstructor(access = AccessLevel.PRIVATE) public class NodeWithContextComparator implements Comparator { private static final Comparator INSTANCE = new NodeWithContextComparator(); @@ -51,6 +47,8 @@ public class NodeWithContextComparator implements Comparator { return REVERSE; } + private NodeWithContextComparator() {} + @Override public int compare(LocalizedNode one, LocalizedNode two) { Node o1 = one.getNode(); diff --git a/common/src/main/java/me/lucko/luckperms/common/node/ShorthandParser.java b/common/src/main/java/me/lucko/luckperms/common/node/ShorthandParser.java index c555fc0e1..11e49e638 100644 --- a/common/src/main/java/me/lucko/luckperms/common/node/ShorthandParser.java +++ b/common/src/main/java/me/lucko/luckperms/common/node/ShorthandParser.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.node; -import lombok.experimental.UtilityClass; - import com.google.common.base.Splitter; import com.google.common.collect.ImmutableList; @@ -39,8 +37,7 @@ import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.IntStream; -@UtilityClass -public class ShorthandParser { +public final class ShorthandParser { private static final List>> PARSERS = ImmutableList.>>builder() .add(new ListParser()) .add(new CharacterRangeParser()) @@ -172,4 +169,6 @@ public class ShorthandParser { } } + private ShorthandParser() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/primarygroup/AllParentsByWeightHolder.java b/common/src/main/java/me/lucko/luckperms/common/primarygroup/AllParentsByWeightHolder.java index 18959366e..d6538ed7f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/primarygroup/AllParentsByWeightHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/primarygroup/AllParentsByWeightHolder.java @@ -42,18 +42,18 @@ public class AllParentsByWeightHolder extends CachedPrimaryGroupHolder { @Override protected String calculateValue() { - Contexts contexts = user.getPlugin().getContextForUser(user); + Contexts contexts = this.user.getPlugin().getContextForUser(this.user); if (contexts == null) { - contexts = user.getPlugin().getContextManager().getStaticContexts(); + contexts = this.user.getPlugin().getContextManager().getStaticContexts(); } // hack to get a list of groups the holder is inheriting from Set groupNames = new LinkedHashSet<>(); - user.resolveInheritances(new NoopList<>(), groupNames, contexts); + this.user.resolveInheritances(new NoopList<>(), groupNames, contexts); List groups = new ArrayList<>(); for (String groupName : groupNames) { - Group group = user.getPlugin().getGroupManager().getIfLoaded(groupName); + Group group = this.user.getPlugin().getGroupManager().getIfLoaded(groupName); if (group != null) { groups.add(group); } diff --git a/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java b/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java index 12a3a9503..9bea72f3a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/primarygroup/CachedPrimaryGroupHolder.java @@ -52,13 +52,13 @@ public abstract class CachedPrimaryGroupHolder extends StoredHolder implements S @Override public String getValue() { - String s = cache.get(); + String s = this.cache.get(); return s != null ? s : getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME); } @Override public void onStateChange() { - cache.invalidate(); + this.cache.invalidate(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/primarygroup/GroupInheritanceComparator.java b/common/src/main/java/me/lucko/luckperms/common/primarygroup/GroupInheritanceComparator.java index 53ac2f506..26114e8f2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/primarygroup/GroupInheritanceComparator.java +++ b/common/src/main/java/me/lucko/luckperms/common/primarygroup/GroupInheritanceComparator.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.primarygroup; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.model.PermissionHolder; import me.lucko.luckperms.common.model.User; @@ -38,7 +35,6 @@ import java.util.Comparator; /** * Determines the order of group inheritance in {@link PermissionHolder}. */ -@AllArgsConstructor(access = AccessLevel.PRIVATE) public class GroupInheritanceComparator implements Comparator { private static final Comparator NULL_ORIGIN = new GroupInheritanceComparator(null); @@ -51,6 +47,10 @@ public class GroupInheritanceComparator implements Comparator { private final User origin; + private GroupInheritanceComparator(User origin) { + this.origin = origin; + } + @Override public int compare(Group o1, Group o2) { int ret = Integer.compare(o1.getWeight().orElse(0), o2.getWeight().orElse(0)); @@ -60,9 +60,9 @@ public class GroupInheritanceComparator implements Comparator { } // failing differing group weights, check if one of the groups is a primary group - if (origin != null) { - boolean o1Primary = o1.getName().equalsIgnoreCase(origin.getPrimaryGroup().getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME)); - boolean o2Primary = o2.getName().equalsIgnoreCase(origin.getPrimaryGroup().getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME)); + if (this.origin != null) { + boolean o1Primary = o1.getName().equalsIgnoreCase(this.origin.getPrimaryGroup().getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME)); + boolean o2Primary = o2.getName().equalsIgnoreCase(this.origin.getPrimaryGroup().getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME)); // one of them is a primary group, and therefore has priority if (o1Primary != o2Primary) { diff --git a/common/src/main/java/me/lucko/luckperms/common/primarygroup/ParentsByWeightHolder.java b/common/src/main/java/me/lucko/luckperms/common/primarygroup/ParentsByWeightHolder.java index c37701369..59d259342 100644 --- a/common/src/main/java/me/lucko/luckperms/common/primarygroup/ParentsByWeightHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/primarygroup/ParentsByWeightHolder.java @@ -40,18 +40,18 @@ public class ParentsByWeightHolder extends CachedPrimaryGroupHolder { @Override protected String calculateValue() { - Contexts contexts = user.getPlugin().getContextForUser(user); + Contexts contexts = this.user.getPlugin().getContextForUser(this.user); if (contexts == null) { - contexts = user.getPlugin().getContextManager().getStaticContexts(); + contexts = this.user.getPlugin().getContextManager().getStaticContexts(); } Set groups = new LinkedHashSet<>(); - for (Node node : user.filterNodes(contexts.getContexts())) { + for (Node node : this.user.filterNodes(contexts.getContexts())) { if (!node.getValuePrimitive() || !node.isGroupNode()) { continue; } - Group group = user.getPlugin().getGroupManager().getIfLoaded(node.getGroupName()); + Group group = this.user.getPlugin().getGroupManager().getIfLoaded(node.getGroupName()); if (group != null) { groups.add(group); } diff --git a/common/src/main/java/me/lucko/luckperms/common/primarygroup/StoredHolder.java b/common/src/main/java/me/lucko/luckperms/common/primarygroup/StoredHolder.java index eb8b317ee..367110578 100644 --- a/common/src/main/java/me/lucko/luckperms/common/primarygroup/StoredHolder.java +++ b/common/src/main/java/me/lucko/luckperms/common/primarygroup/StoredHolder.java @@ -25,10 +25,9 @@ package me.lucko.luckperms.common.primarygroup; -import lombok.NonNull; - import me.lucko.luckperms.common.model.User; +import java.util.Objects; import java.util.Optional; /** @@ -40,19 +39,21 @@ public class StoredHolder implements PrimaryGroupHolder { private String storedValue = null; - public StoredHolder(@NonNull User user) { - this.user = user; + public StoredHolder(User user) { + this.user = Objects.requireNonNull(user, "user"); } + @Override public String getValue() { - return storedValue; + return this.storedValue; } @Override public Optional getStoredValue() { - return Optional.ofNullable(storedValue); + return Optional.ofNullable(this.storedValue); } + @Override public void setStoredValue(String storedValue) { if (storedValue == null || storedValue.isEmpty()) { this.storedValue = null; diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java index 082154672..fe5d9d395 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/MapProcessor.java @@ -34,7 +34,7 @@ public class MapProcessor implements PermissionProcessor { @Override public Tristate hasPermission(String permission) { - return Tristate.fromNullableBoolean(map.get(permission)); + return Tristate.fromNullableBoolean(this.map.get(permission)); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java index 484d872a6..3d02d2857 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/RegexProcessor.java @@ -37,7 +37,7 @@ public class RegexProcessor implements PermissionProcessor { @Override public Tristate hasPermission(String permission) { - for (Map.Entry e : regexPermissions.entrySet()) { + for (Map.Entry e : this.regexPermissions.entrySet()) { if (e.getKey().matcher(permission).matches()) { return Tristate.fromBoolean(e.getValue()); } @@ -48,7 +48,7 @@ public class RegexProcessor implements PermissionProcessor { @Override public void updateBacking(Map map) { - regexPermissions.clear(); + this.regexPermissions.clear(); for (Map.Entry e : map.entrySet()) { if (!e.getKey().startsWith("r=") && !e.getKey().startsWith("R=")) { continue; @@ -61,7 +61,7 @@ public class RegexProcessor implements PermissionProcessor { continue; } - regexPermissions.put(p, e.getValue()); + this.regexPermissions.put(p, e.getValue()); } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java b/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java index d5b75d189..22538c724 100644 --- a/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java +++ b/common/src/main/java/me/lucko/luckperms/common/processors/WildcardProcessor.java @@ -49,19 +49,19 @@ public class WildcardProcessor implements PermissionProcessor { node = node.substring(0, endIndex); if (!node.isEmpty()) { - Tristate t = Tristate.fromNullableBoolean(map.get(node + WILDCARD_SUFFIX)); + Tristate t = Tristate.fromNullableBoolean(this.map.get(node + WILDCARD_SUFFIX)); if (t != Tristate.UNDEFINED) { return t; } } } - Tristate t = Tristate.fromNullableBoolean(map.get(GLOBAL_WILDCARD_1)); + Tristate t = Tristate.fromNullableBoolean(this.map.get(GLOBAL_WILDCARD_1)); if (t != Tristate.UNDEFINED) { return t; } - return Tristate.fromNullableBoolean(map.get(GLOBAL_WILDCARD_2)); + return Tristate.fromNullableBoolean(this.map.get(GLOBAL_WILDCARD_2)); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/references/GroupReference.java b/common/src/main/java/me/lucko/luckperms/common/references/GroupReference.java index d5f9eddf5..66835fc58 100644 --- a/common/src/main/java/me/lucko/luckperms/common/references/GroupReference.java +++ b/common/src/main/java/me/lucko/luckperms/common/references/GroupReference.java @@ -25,24 +25,22 @@ package me.lucko.luckperms.common.references; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.function.Consumer; -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor(staticName = "of") -public class GroupReference implements HolderReference { +public final class GroupReference implements HolderReference { + public static GroupReference of(String id) { + return new GroupReference(id); + } private final String id; + private GroupReference(String id) { + this.id = id; + } + @Override public HolderType getType() { return HolderType.GROUP; @@ -50,10 +48,32 @@ public class GroupReference implements HolderReference { @Override public void apply(LuckPermsPlugin plugin, Consumer consumer) { - Group group = plugin.getGroupManager().getIfLoaded(id); + Group group = plugin.getGroupManager().getIfLoaded(this.id); if (group == null) return; consumer.accept(group); } + @Override + public String getId() { + return this.id; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof GroupReference)) return false; + final GroupReference other = (GroupReference) o; + return this.getId().equals(other.getId()); + } + + @Override + public int hashCode() { + return this.id.hashCode(); + } + + @Override + public String toString() { + return "GroupReference(id=" + this.getId() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/references/HolderType.java b/common/src/main/java/me/lucko/luckperms/common/references/HolderType.java index 7e3479fee..bccd04b0b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/references/HolderType.java +++ b/common/src/main/java/me/lucko/luckperms/common/references/HolderType.java @@ -25,13 +25,8 @@ package me.lucko.luckperms.common.references; -import lombok.AllArgsConstructor; -import lombok.Getter; - import me.lucko.luckperms.common.model.PermissionHolder; -@Getter -@AllArgsConstructor public enum HolderType { USER(true, false), @@ -40,6 +35,11 @@ public enum HolderType { private final boolean user; private final boolean group; + HolderType(boolean user, boolean group) { + this.user = user; + this.group = group; + } + public boolean matches(PermissionHolder holder) { return holder.getType() == this; } @@ -48,4 +48,12 @@ public enum HolderType { public String toString() { return name().toLowerCase(); } + + public boolean isUser() { + return this.user; + } + + public boolean isGroup() { + return this.group; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/references/UserIdentifier.java b/common/src/main/java/me/lucko/luckperms/common/references/UserIdentifier.java index 9a7044a6f..334c0717d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/references/UserIdentifier.java +++ b/common/src/main/java/me/lucko/luckperms/common/references/UserIdentifier.java @@ -25,12 +25,6 @@ package me.lucko.luckperms.common.references; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.common.model.User; import java.util.Optional; @@ -39,9 +33,6 @@ import java.util.UUID; /** * Used to identify a specific {@link User}. */ -@ToString -@EqualsAndHashCode(of = "uuid") -@AllArgsConstructor(access = AccessLevel.PRIVATE) public final class UserIdentifier implements Identifiable { public static UserIdentifier of(UUID uuid, String username) { if (username == null || username.equalsIgnoreCase("null") || username.isEmpty()) { @@ -51,16 +42,42 @@ public final class UserIdentifier implements Identifiable { return new UserIdentifier(uuid, username); } - @Getter private final UUID uuid; private final String username; + private UserIdentifier(UUID uuid, String username) { + this.uuid = uuid; + this.username = username; + } + @Override public UUID getId() { return getUuid(); } public Optional getUsername() { - return Optional.ofNullable(username); + return Optional.ofNullable(this.username); + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof UserIdentifier)) return false; + final UserIdentifier other = (UserIdentifier) o; + return this.uuid.equals(other.uuid); + } + + @Override + public int hashCode() { + return this.uuid.hashCode(); + } + + @Override + public String toString() { + return "UserIdentifier(uuid=" + this.uuid + ", username=" + this.getUsername() + ")"; + } + + public UUID getUuid() { + return this.uuid; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/references/UserReference.java b/common/src/main/java/me/lucko/luckperms/common/references/UserReference.java index 54d6ee6f7..cf60ad1d9 100644 --- a/common/src/main/java/me/lucko/luckperms/common/references/UserReference.java +++ b/common/src/main/java/me/lucko/luckperms/common/references/UserReference.java @@ -25,23 +25,22 @@ package me.lucko.luckperms.common.references; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.common.model.User; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.util.function.Consumer; -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor(staticName = "of") public final class UserReference implements HolderReference { + public static UserReference of(UserIdentifier id) { + return new UserReference(id); + } + private final UserIdentifier id; + private UserReference(UserIdentifier id) { + this.id = id; + } + @Override public HolderType getType() { return HolderType.USER; @@ -49,10 +48,32 @@ public final class UserReference implements HolderReference consumer) { - User user = plugin.getUserManager().getIfLoaded(id); + User user = plugin.getUserManager().getIfLoaded(this.id); if (user == null) return; consumer.accept(user); } + @Override + public UserIdentifier getId() { + return this.id; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof UserReference)) return false; + final UserReference other = (UserReference) o; + return this.id.equals(other.id); + } + + @Override + public int hashCode() { + return this.id.hashCode(); + } + + @Override + public String toString() { + return "UserReference(id=" + this.getId() + ")"; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/AbstractStorage.java b/common/src/main/java/me/lucko/luckperms/common/storage/AbstractStorage.java index 5d8979b6b..679ef4359 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/AbstractStorage.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/AbstractStorage.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.storage; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.google.common.base.Throwables; import me.lucko.luckperms.api.HeldPermission; @@ -58,7 +54,6 @@ import java.util.concurrent.CompletionException; /** * Converts a {@link AbstractDao} to use {@link CompletableFuture}s */ -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) public class AbstractStorage implements Storage { public static Storage create(LuckPermsPlugin plugin, AbstractDao backing) { BufferedOutputStorage bufferedDs = BufferedOutputStorage.wrap(PhasedStorage.wrap(new AbstractStorage(plugin, backing)), 250L); @@ -69,7 +64,6 @@ public class AbstractStorage implements Storage { private final LuckPermsPlugin plugin; private final AbstractDao dao; - @Getter private final ApiStorage delegate; private AbstractStorage(LuckPermsPlugin plugin, AbstractDao dao) { @@ -86,7 +80,7 @@ public class AbstractStorage implements Storage { Throwables.propagateIfPossible(e); throw new CompletionException(e); } - }, dao.getPlugin().getScheduler().async()); + }, this.dao.getPlugin().getScheduler().async()); } private CompletableFuture makeFuture(ThrowingRunnable runnable) { @@ -97,7 +91,12 @@ public class AbstractStorage implements Storage { Throwables.propagateIfPossible(e); throw new CompletionException(e); } - }, dao.getPlugin().getScheduler().async()); + }, this.dao.getPlugin().getScheduler().async()); + } + + @Override + public ApiStorage getDelegate() { + return this.delegate; } private interface ThrowingRunnable { @@ -106,7 +105,7 @@ public class AbstractStorage implements Storage { @Override public String getName() { - return dao.getName(); + return this.dao.getName(); } @Override @@ -117,9 +116,9 @@ public class AbstractStorage implements Storage { @Override public void init() { try { - dao.init(); + this.dao.init(); } catch (Exception e) { - plugin.getLog().severe("Failed to init storage dao"); + this.plugin.getLog().severe("Failed to init storage dao"); e.printStackTrace(); } } @@ -127,39 +126,39 @@ public class AbstractStorage implements Storage { @Override public void shutdown() { try { - dao.shutdown(); + this.dao.shutdown(); } catch (Exception e) { - plugin.getLog().severe("Failed to shutdown storage dao"); + this.plugin.getLog().severe("Failed to shutdown storage dao"); e.printStackTrace(); } } @Override public Map getMeta() { - return dao.getMeta(); + return this.dao.getMeta(); } @Override public CompletableFuture logAction(LogEntry entry) { - return makeFuture(() -> dao.logAction(entry)); + return makeFuture(() -> this.dao.logAction(entry)); } @Override public CompletableFuture getLog() { - return makeFuture(dao::getLog); + return makeFuture(this.dao::getLog); } @Override public CompletableFuture applyBulkUpdate(BulkUpdate bulkUpdate) { - return makeFuture(() -> dao.applyBulkUpdate(bulkUpdate)); + return makeFuture(() -> this.dao.applyBulkUpdate(bulkUpdate)); } @Override public CompletableFuture loadUser(UUID uuid, String username) { return makeFuture(() -> { - User user = dao.loadUser(uuid, username); + User user = this.dao.loadUser(uuid, username); if (user != null) { - plugin.getEventFactory().handleUserLoad(user); + this.plugin.getEventFactory().handleUserLoad(user); } return user; }); @@ -167,25 +166,25 @@ public class AbstractStorage implements Storage { @Override public CompletableFuture saveUser(User user) { - return makeFuture(() -> dao.saveUser(user)); + return makeFuture(() -> this.dao.saveUser(user)); } @Override public CompletableFuture> getUniqueUsers() { - return makeFuture(dao::getUniqueUsers); + return makeFuture(this.dao::getUniqueUsers); } @Override public CompletableFuture>> getUsersWithPermission(String permission) { - return makeFuture(() -> dao.getUsersWithPermission(permission)); + return makeFuture(() -> this.dao.getUsersWithPermission(permission)); } @Override public CompletableFuture createAndLoadGroup(String name, CreationCause cause) { return makeFuture(() -> { - Group group = dao.createAndLoadGroup(name); + Group group = this.dao.createAndLoadGroup(name); if (group != null) { - plugin.getEventFactory().handleGroupCreate(group, cause); + this.plugin.getEventFactory().handleGroupCreate(group, cause); } return group; }); @@ -194,9 +193,9 @@ public class AbstractStorage implements Storage { @Override public CompletableFuture> loadGroup(String name) { return makeFuture(() -> { - Optional group = dao.loadGroup(name); + Optional group = this.dao.loadGroup(name); if (group.isPresent()) { - plugin.getEventFactory().handleGroupLoad(group.get()); + this.plugin.getEventFactory().handleGroupLoad(group.get()); } return group; }); @@ -205,35 +204,35 @@ public class AbstractStorage implements Storage { @Override public CompletableFuture loadAllGroups() { return makeFuture(() -> { - dao.loadAllGroups(); - plugin.getEventFactory().handleGroupLoadAll(); + this.dao.loadAllGroups(); + this.plugin.getEventFactory().handleGroupLoadAll(); }); } @Override public CompletableFuture saveGroup(Group group) { - return makeFuture(() -> dao.saveGroup(group)); + return makeFuture(() -> this.dao.saveGroup(group)); } @Override public CompletableFuture deleteGroup(Group group, DeletionCause cause) { return makeFuture(() -> { - dao.deleteGroup(group); - plugin.getEventFactory().handleGroupDelete(group, cause); + this.dao.deleteGroup(group); + this.plugin.getEventFactory().handleGroupDelete(group, cause); }); } @Override public CompletableFuture>> getGroupsWithPermission(String permission) { - return makeFuture(() -> dao.getGroupsWithPermission(permission)); + return makeFuture(() -> this.dao.getGroupsWithPermission(permission)); } @Override public CompletableFuture createAndLoadTrack(String name, CreationCause cause) { return makeFuture(() -> { - Track track = dao.createAndLoadTrack(name); + Track track = this.dao.createAndLoadTrack(name); if (track != null) { - plugin.getEventFactory().handleTrackCreate(track, cause); + this.plugin.getEventFactory().handleTrackCreate(track, cause); } return track; }); @@ -242,9 +241,9 @@ public class AbstractStorage implements Storage { @Override public CompletableFuture> loadTrack(String name) { return makeFuture(() -> { - Optional track = dao.loadTrack(name); + Optional track = this.dao.loadTrack(name); if (track.isPresent()) { - plugin.getEventFactory().handleTrackLoad(track.get()); + this.plugin.getEventFactory().handleTrackLoad(track.get()); } return track; }); @@ -253,36 +252,36 @@ public class AbstractStorage implements Storage { @Override public CompletableFuture loadAllTracks() { return makeFuture(() -> { - dao.loadAllTracks(); - plugin.getEventFactory().handleTrackLoadAll(); + this.dao.loadAllTracks(); + this.plugin.getEventFactory().handleTrackLoadAll(); }); } @Override public CompletableFuture saveTrack(Track track) { - return makeFuture(() -> dao.saveTrack(track)); + return makeFuture(() -> this.dao.saveTrack(track)); } @Override public CompletableFuture deleteTrack(Track track, DeletionCause cause) { return makeFuture(() -> { - dao.deleteTrack(track); - plugin.getEventFactory().handleTrackDelete(track, cause); + this.dao.deleteTrack(track); + this.plugin.getEventFactory().handleTrackDelete(track, cause); }); } @Override public CompletableFuture saveUUIDData(UUID uuid, String username) { - return makeFuture(() -> dao.saveUUIDData(uuid, username)); + return makeFuture(() -> this.dao.saveUUIDData(uuid, username)); } @Override public CompletableFuture getUUID(String username) { - return makeFuture(() -> dao.getUUID(username)); + return makeFuture(() -> this.dao.getUUID(username)); } @Override public CompletableFuture getName(UUID uuid) { - return makeFuture(() -> dao.getName(uuid)); + return makeFuture(() -> this.dao.getName(uuid)); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/DataConstraints.java b/common/src/main/java/me/lucko/luckperms/common/storage/DataConstraints.java index 7d342bea7..1c8b2fb05 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/DataConstraints.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/DataConstraints.java @@ -25,15 +25,12 @@ package me.lucko.luckperms.common.storage; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.common.utils.DateUtil; import java.util.function.Predicate; import java.util.regex.Pattern; -@UtilityClass -public class DataConstraints { +public final class DataConstraints { public static final int MAX_PERMISSION_LENGTH = 200; @@ -46,24 +43,26 @@ public class DataConstraints { public static final int MAX_SERVER_LENGTH = 36; public static final int MAX_WORLD_LENGTH = 36; - public static final Predicate PERMISSION_TEST = s -> s.length() > 0 && s.length() <= MAX_PERMISSION_LENGTH; + public static final Predicate PERMISSION_TEST = s -> !s.isEmpty() && s.length() <= MAX_PERMISSION_LENGTH; - public static final Predicate PLAYER_USERNAME_TEST = s -> s.length() > 0 && s.length() <= MAX_PLAYER_USERNAME_LENGTH && !PLAYER_USERNAME_INVALID_CHAR_MATCHER.matcher(s).find(); + public static final Predicate PLAYER_USERNAME_TEST = s -> !s.isEmpty() && s.length() <= MAX_PLAYER_USERNAME_LENGTH && !PLAYER_USERNAME_INVALID_CHAR_MATCHER.matcher(s).find(); - public static final Predicate PLAYER_USERNAME_TEST_LENIENT = s -> s.length() > 0 && s.length() <= MAX_PLAYER_USERNAME_LENGTH; + public static final Predicate PLAYER_USERNAME_TEST_LENIENT = s -> !s.isEmpty() && s.length() <= MAX_PLAYER_USERNAME_LENGTH; - public static final Predicate GROUP_NAME_TEST = s -> s.length() > 0 && s.length() <= MAX_GROUP_NAME_LENGTH && !s.contains(" "); + public static final Predicate GROUP_NAME_TEST = s -> !s.isEmpty() && s.length() <= MAX_GROUP_NAME_LENGTH && !s.contains(" "); - public static final Predicate GROUP_NAME_TEST_ALLOW_SPACE = s -> s.length() > 0 && s.length() <= MAX_GROUP_NAME_LENGTH; + public static final Predicate GROUP_NAME_TEST_ALLOW_SPACE = s -> !s.isEmpty() && s.length() <= MAX_GROUP_NAME_LENGTH; - public static final Predicate TRACK_NAME_TEST = s -> s.length() > 0 && s.length() <= MAX_TRACK_NAME_LENGTH && !s.contains(" "); + public static final Predicate TRACK_NAME_TEST = s -> !s.isEmpty() && s.length() <= MAX_TRACK_NAME_LENGTH && !s.contains(" "); - public static final Predicate TRACK_NAME_TEST_ALLOW_SPACE = s -> s.length() > 0 && s.length() <= MAX_TRACK_NAME_LENGTH; + public static final Predicate TRACK_NAME_TEST_ALLOW_SPACE = s -> !s.isEmpty() && s.length() <= MAX_TRACK_NAME_LENGTH; public static final Predicate TIME_TEST = unixTime -> !DateUtil.shouldExpire(unixTime); - public static final Predicate SERVER_NAME_TEST = s -> s.length() > 0 && s.length() <= MAX_SERVER_LENGTH && !s.contains(" "); + public static final Predicate SERVER_NAME_TEST = s -> !s.isEmpty() && s.length() <= MAX_SERVER_LENGTH && !s.contains(" "); - public static final Predicate WORLD_NAME_TEST = s -> s.length() > 0 && s.length() <= MAX_WORLD_LENGTH; + public static final Predicate WORLD_NAME_TEST = s -> !s.isEmpty() && s.length() <= MAX_WORLD_LENGTH; + + private DataConstraints() {} } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/StorageCredentials.java b/common/src/main/java/me/lucko/luckperms/common/storage/StorageCredentials.java index 2fc5be46d..f888fbcc8 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/StorageCredentials.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/StorageCredentials.java @@ -25,23 +25,65 @@ package me.lucko.luckperms.common.storage; -import lombok.AllArgsConstructor; -import lombok.Getter; - import java.util.Map; -@Getter -@AllArgsConstructor public class StorageCredentials { private final String address; private final String database; private final String username; private final String password; - private int maxPoolSize; - private int minIdleConnections; - private int maxLifetime; - private int connectionTimeout; - private Map properties; + private final int maxPoolSize; + private final int minIdleConnections; + private final int maxLifetime; + private final int connectionTimeout; + private final Map properties; + public StorageCredentials(String address, String database, String username, String password, int maxPoolSize, int minIdleConnections, int maxLifetime, int connectionTimeout, Map properties) { + this.address = address; + this.database = database; + this.username = username; + this.password = password; + this.maxPoolSize = maxPoolSize; + this.minIdleConnections = minIdleConnections; + this.maxLifetime = maxLifetime; + this.connectionTimeout = connectionTimeout; + this.properties = properties; + } + + public String getAddress() { + return this.address; + } + + public String getDatabase() { + return this.database; + } + + public String getUsername() { + return this.username; + } + + public String getPassword() { + return this.password; + } + + public int getMaxPoolSize() { + return this.maxPoolSize; + } + + public int getMinIdleConnections() { + return this.minIdleConnections; + } + + public int getMaxLifetime() { + return this.maxLifetime; + } + + public int getConnectionTimeout() { + return this.connectionTimeout; + } + + public Map getProperties() { + return this.properties; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/StorageFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/StorageFactory.java index 0aafd26f9..69b7f7e40 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/StorageFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/StorageFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage; -import lombok.AllArgsConstructor; - import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; @@ -50,18 +48,20 @@ import java.io.File; import java.util.Map; import java.util.Set; -@AllArgsConstructor public class StorageFactory { - private final LuckPermsPlugin plugin; + public StorageFactory(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + public Set getRequiredTypes(StorageType defaultMethod) { - if (plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE)) { - return plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream() + if (this.plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE)) { + return this.plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream() .map(e -> { StorageType type = StorageType.parse(e.getValue()); if (type == null) { - plugin.getLog().severe("Storage method for " + e.getKey() + " - " + e.getValue() + " not recognised. " + + this.plugin.getLog().severe("Storage method for " + e.getKey() + " - " + e.getValue() + " not recognised. " + "Using the default instead."); type = defaultMethod; } @@ -69,10 +69,10 @@ public class StorageFactory { }) .collect(ImmutableCollectors.toEnumSet(StorageType.class)); } else { - String method = plugin.getConfiguration().get(ConfigKeys.STORAGE_METHOD); + String method = this.plugin.getConfiguration().get(ConfigKeys.STORAGE_METHOD); StorageType type = StorageType.parse(method); if (type == null) { - plugin.getLog().severe("Storage method '" + method + "' not recognised. Using the default instead."); + this.plugin.getLog().severe("Storage method '" + method + "' not recognised. Using the default instead."); type = defaultMethod; } return ImmutableSet.of(type); @@ -81,10 +81,10 @@ public class StorageFactory { public Storage getInstance(StorageType defaultMethod) { Storage storage; - if (plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE)) { - plugin.getLog().info("Loading storage provider... [SPLIT STORAGE]"); + if (this.plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE)) { + this.plugin.getLog().info("Loading storage provider... [SPLIT STORAGE]"); - Map mappedTypes = plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream() + Map mappedTypes = this.plugin.getConfiguration().get(ConfigKeys.SPLIT_STORAGE_OPTIONS).entrySet().stream() .map(e -> { StorageType type = StorageType.parse(e.getValue()); if (type == null) { @@ -98,16 +98,16 @@ public class StorageFactory { .distinct() .collect(ImmutableCollectors.toEnumMap(StorageType.class, e -> e, this::makeDao)); - storage = AbstractStorage.create(plugin, new SplitStorageDao(plugin, backing, mappedTypes)); + storage = AbstractStorage.create(this.plugin, new SplitStorageDao(this.plugin, backing, mappedTypes)); } else { - String method = plugin.getConfiguration().get(ConfigKeys.STORAGE_METHOD); + String method = this.plugin.getConfiguration().get(ConfigKeys.STORAGE_METHOD); StorageType type = StorageType.parse(method); if (type == null) { type = defaultMethod; } - plugin.getLog().info("Loading storage provider... [" + type.name() + "]"); + this.plugin.getLog().info("Loading storage provider... [" + type.name() + "]"); storage = makeInstance(type); } @@ -116,48 +116,48 @@ public class StorageFactory { } private Storage makeInstance(StorageType type) { - return AbstractStorage.create(plugin, makeDao(type)); + return AbstractStorage.create(this.plugin, makeDao(type)); } private AbstractDao makeDao(StorageType method) { switch (method) { case MARIADB: - return new SqlDao(plugin, new MariaDbConnectionFactory( - plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES)), - plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) + return new SqlDao(this.plugin, new MariaDbConnectionFactory( + this.plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES)), + this.plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) ); case MYSQL: - return new SqlDao(plugin, new MySqlConnectionFactory( - plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES)), - plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) + return new SqlDao(this.plugin, new MySqlConnectionFactory( + this.plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES)), + this.plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) ); case SQLITE: - return new SqlDao(plugin, new SQLiteConnectionFactory( - new File(plugin.getDataDirectory(), "luckperms-sqlite.db")), - plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) + return new SqlDao(this.plugin, new SQLiteConnectionFactory( + new File(this.plugin.getDataDirectory(), "luckperms-sqlite.db")), + this.plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) ); case H2: - return new SqlDao(plugin, new H2ConnectionFactory( - new File(plugin.getDataDirectory(), "luckperms-h2")), - plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) + return new SqlDao(this.plugin, new H2ConnectionFactory( + new File(this.plugin.getDataDirectory(), "luckperms-h2")), + this.plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) ); case POSTGRESQL: - return new SqlDao(plugin, new PostgreConnectionFactory( - plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES)), - plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) + return new SqlDao(this.plugin, new PostgreConnectionFactory( + this.plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES)), + this.plugin.getConfiguration().get(ConfigKeys.SQL_TABLE_PREFIX) ); case MONGODB: return new MongoDao( - plugin, - plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES), - plugin.getConfiguration().get(ConfigKeys.MONGODB_COLLECTION_PREFIX) + this.plugin, + this.plugin.getConfiguration().get(ConfigKeys.DATABASE_VALUES), + this.plugin.getConfiguration().get(ConfigKeys.MONGODB_COLLECTION_PREFIX) ); case YAML: - return new YamlDao(plugin, "yaml-storage"); + return new YamlDao(this.plugin, "yaml-storage"); case HOCON: - return new HoconDao(plugin, "hocon-storage"); + return new HoconDao(this.plugin, "hocon-storage"); default: - return new JsonDao(plugin, "json-storage"); + return new JsonDao(this.plugin, "json-storage"); } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/StorageType.java b/common/src/main/java/me/lucko/luckperms/common/storage/StorageType.java index 55d650842..1aa9c96c7 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/StorageType.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/StorageType.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import java.util.List; @@ -43,10 +41,8 @@ public enum StorageType { SQLITE("SQLite", "sqlite"), H2("H2", "h2"); - @Getter private final String name; - @Getter private final List identifiers; StorageType(String name, String... identifiers) { @@ -65,4 +61,11 @@ public enum StorageType { return null; } + public String getName() { + return this.name; + } + + public List getIdentifiers() { + return this.identifiers; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/AbstractDao.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/AbstractDao.java index 472c6feb0..14df2a55f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/AbstractDao.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/AbstractDao.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.common.storage.dao; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.HeldPermission; import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.common.actionlog.Log; @@ -45,15 +41,24 @@ import java.util.Optional; import java.util.Set; import java.util.UUID; -@RequiredArgsConstructor(access = AccessLevel.PROTECTED) public abstract class AbstractDao { - @Getter protected final LuckPermsPlugin plugin; - - @Getter public final String name; + protected AbstractDao(LuckPermsPlugin plugin, String name) { + this.plugin = plugin; + this.name = name; + } + + public LuckPermsPlugin getPlugin() { + return this.plugin; + } + + public String getName() { + return this.name; + } + public abstract void init(); public abstract void shutdown(); diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/SplitStorageDao.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/SplitStorageDao.java index ddb812d84..7d4df1bf2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/SplitStorageDao.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/SplitStorageDao.java @@ -58,7 +58,7 @@ public class SplitStorageDao extends AbstractDao { @Override public void init() { boolean failed = false; - for (AbstractDao ds : backing.values()) { + for (AbstractDao ds : this.backing.values()) { try { ds.init(); } catch (Exception ex) { @@ -73,7 +73,7 @@ public class SplitStorageDao extends AbstractDao { @Override public void shutdown() { - for (AbstractDao ds : backing.values()) { + for (AbstractDao ds : this.backing.values()) { try { ds.shutdown(); } catch (Exception e) { @@ -85,8 +85,8 @@ public class SplitStorageDao extends AbstractDao { @Override public Map getMeta() { Map ret = new LinkedHashMap<>(); - ret.put("Types", types.toString()); - for (AbstractDao backing : backing.values()) { + ret.put("Types", this.types.toString()); + for (AbstractDao backing : this.backing.values()) { ret.putAll(backing.getMeta()); } return ret; @@ -94,114 +94,114 @@ public class SplitStorageDao extends AbstractDao { @Override public void logAction(LogEntry entry) throws Exception { - backing.get(types.get(SplitStorageType.LOG)).logAction(entry); + this.backing.get(this.types.get(SplitStorageType.LOG)).logAction(entry); } @Override public Log getLog() throws Exception { - return backing.get(types.get(SplitStorageType.LOG)).getLog(); + return this.backing.get(this.types.get(SplitStorageType.LOG)).getLog(); } @Override public void applyBulkUpdate(BulkUpdate bulkUpdate) throws Exception { - StorageType userType = types.get(SplitStorageType.USER); - StorageType groupType = types.get(SplitStorageType.GROUP); + StorageType userType = this.types.get(SplitStorageType.USER); + StorageType groupType = this.types.get(SplitStorageType.GROUP); - backing.get(userType).applyBulkUpdate(bulkUpdate); + this.backing.get(userType).applyBulkUpdate(bulkUpdate); // if differs - if (!userType.equals(groupType)) { - backing.get(groupType).applyBulkUpdate(bulkUpdate); + if (userType != groupType) { + this.backing.get(groupType).applyBulkUpdate(bulkUpdate); } } @Override public User loadUser(UUID uuid, String username) throws Exception { - return backing.get(types.get(SplitStorageType.USER)).loadUser(uuid, username); + return this.backing.get(this.types.get(SplitStorageType.USER)).loadUser(uuid, username); } @Override public void saveUser(User user) throws Exception { - backing.get(types.get(SplitStorageType.USER)).saveUser(user); + this.backing.get(this.types.get(SplitStorageType.USER)).saveUser(user); } @Override public Set getUniqueUsers() throws Exception { - return backing.get(types.get(SplitStorageType.USER)).getUniqueUsers(); + return this.backing.get(this.types.get(SplitStorageType.USER)).getUniqueUsers(); } @Override public List> getUsersWithPermission(String permission) throws Exception { - return backing.get(types.get(SplitStorageType.USER)).getUsersWithPermission(permission); + return this.backing.get(this.types.get(SplitStorageType.USER)).getUsersWithPermission(permission); } @Override public Group createAndLoadGroup(String name) throws Exception { - return backing.get(types.get(SplitStorageType.GROUP)).createAndLoadGroup(name); + return this.backing.get(this.types.get(SplitStorageType.GROUP)).createAndLoadGroup(name); } @Override public Optional loadGroup(String name) throws Exception { - return backing.get(types.get(SplitStorageType.GROUP)).loadGroup(name); + return this.backing.get(this.types.get(SplitStorageType.GROUP)).loadGroup(name); } @Override public void loadAllGroups() throws Exception { - backing.get(types.get(SplitStorageType.GROUP)).loadAllGroups(); + this.backing.get(this.types.get(SplitStorageType.GROUP)).loadAllGroups(); } @Override public void saveGroup(Group group) throws Exception { - backing.get(types.get(SplitStorageType.GROUP)).saveGroup(group); + this.backing.get(this.types.get(SplitStorageType.GROUP)).saveGroup(group); } @Override public void deleteGroup(Group group) throws Exception { - backing.get(types.get(SplitStorageType.GROUP)).deleteGroup(group); + this.backing.get(this.types.get(SplitStorageType.GROUP)).deleteGroup(group); } @Override public List> getGroupsWithPermission(String permission) throws Exception { - return backing.get(types.get(SplitStorageType.GROUP)).getGroupsWithPermission(permission); + return this.backing.get(this.types.get(SplitStorageType.GROUP)).getGroupsWithPermission(permission); } @Override public Track createAndLoadTrack(String name) throws Exception { - return backing.get(types.get(SplitStorageType.TRACK)).createAndLoadTrack(name); + return this.backing.get(this.types.get(SplitStorageType.TRACK)).createAndLoadTrack(name); } @Override public Optional loadTrack(String name) throws Exception { - return backing.get(types.get(SplitStorageType.TRACK)).loadTrack(name); + return this.backing.get(this.types.get(SplitStorageType.TRACK)).loadTrack(name); } @Override public void loadAllTracks() throws Exception { - backing.get(types.get(SplitStorageType.TRACK)).loadAllTracks(); + this.backing.get(this.types.get(SplitStorageType.TRACK)).loadAllTracks(); } @Override public void saveTrack(Track track) throws Exception { - backing.get(types.get(SplitStorageType.TRACK)).saveTrack(track); + this.backing.get(this.types.get(SplitStorageType.TRACK)).saveTrack(track); } @Override public void deleteTrack(Track track) throws Exception { - backing.get(types.get(SplitStorageType.TRACK)).deleteTrack(track); + this.backing.get(this.types.get(SplitStorageType.TRACK)).deleteTrack(track); } @Override public void saveUUIDData(UUID uuid, String username) throws Exception { - backing.get(types.get(SplitStorageType.UUID)).saveUUIDData(uuid, username); + this.backing.get(this.types.get(SplitStorageType.UUID)).saveUUIDData(uuid, username); } @Override public UUID getUUID(String username) throws Exception { - return backing.get(types.get(SplitStorageType.UUID)).getUUID(username); + return this.backing.get(this.types.get(SplitStorageType.UUID)).getUUID(username); } @Override public String getName(UUID uuid) throws Exception { - return backing.get(types.get(SplitStorageType.UUID)).getName(uuid); + return this.backing.get(this.types.get(SplitStorageType.UUID)).getName(uuid); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/ConfigurateDao.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/ConfigurateDao.java index 0d2dd4be6..5be08799a 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/ConfigurateDao.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/ConfigurateDao.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage.dao.file; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; @@ -90,9 +88,7 @@ public abstract class ConfigurateDao extends AbstractDao { private final Logger actionLogger = Logger.getLogger("luckperms_actions"); private final FileUuidCache uuidCache = new FileUuidCache(); - @Getter private final String fileExtension; - private final String dataFolderName; private File uuidDataFile; @@ -108,10 +104,14 @@ public abstract class ConfigurateDao extends AbstractDao { this.dataFolderName = dataFolderName; } + public String getFileExtension() { + return this.fileExtension; + } + protected abstract ConfigurationLoader loader(Path path); private ConfigurationNode readFile(StorageLocation location, String name) throws IOException { - File file = new File(getDirectory(location), name + fileExtension); + File file = new File(getDirectory(location), name + this.fileExtension); registerFileAction(location, file); return readFile(file); } @@ -125,7 +125,7 @@ public abstract class ConfigurateDao extends AbstractDao { } private void saveFile(StorageLocation location, String name, ConfigurationNode node) throws IOException { - File file = new File(getDirectory(location), name + fileExtension); + File file = new File(getDirectory(location), name + this.fileExtension); registerFileAction(location, file); saveFile(file, node); } @@ -144,28 +144,28 @@ public abstract class ConfigurateDao extends AbstractDao { private File getDirectory(StorageLocation location) { switch (location) { case USER: - return usersDirectory; + return this.usersDirectory; case GROUP: - return groupsDirectory; + return this.groupsDirectory; case TRACK: - return tracksDirectory; + return this.tracksDirectory; default: throw new RuntimeException(); } } private FilenameFilter getFileTypeFilter() { - return (dir, name) -> name.endsWith(fileExtension); + return (dir, name) -> name.endsWith(this.fileExtension); } private Exception reportException(String file, Exception ex) throws Exception { - plugin.getLog().warn("Exception thrown whilst performing i/o: " + file); + this.plugin.getLog().warn("Exception thrown whilst performing i/o: " + file); ex.printStackTrace(); throw ex; } private void registerFileAction(StorageLocation type, File file) { - plugin.getFileWatcher().ifPresent(fileWatcher -> fileWatcher.registerChange(type, file.getName())); + this.plugin.getFileWatcher().ifPresent(fileWatcher -> fileWatcher.registerChange(type, file.getName())); } @Override @@ -177,20 +177,20 @@ public abstract class ConfigurateDao extends AbstractDao { return; } - uuidCache.load(uuidDataFile); + this.uuidCache.load(this.uuidDataFile); try { - FileHandler fh = new FileHandler(actionLogFile.getAbsolutePath(), 0, 1, true); + FileHandler fh = new FileHandler(this.actionLogFile.getAbsolutePath(), 0, 1, true); fh.setFormatter(new Formatter() { @Override public String format(LogRecord record) { return new Date(record.getMillis()).toString() + ": " + record.getMessage() + "\n"; } }); - actionLogger.addHandler(fh); - actionLogger.setUseParentHandlers(false); - actionLogger.setLevel(Level.ALL); - actionLogger.setFilter(record -> true); + this.actionLogger.addHandler(fh); + this.actionLogger.setUseParentHandlers(false); + this.actionLogger.setLevel(Level.ALL); + this.actionLogger.setFilter(record -> true); } catch (Exception e) { e.printStackTrace(); } @@ -215,27 +215,27 @@ public abstract class ConfigurateDao extends AbstractDao { } private void setupFiles() throws IOException { - File data = new File(plugin.getDataDirectory(), dataFolderName); + File data = new File(this.plugin.getDataDirectory(), this.dataFolderName); // Try to perform schema migration - File oldData = new File(plugin.getDataDirectory(), "data"); + File oldData = new File(this.plugin.getDataDirectory(), "data"); if (!data.exists() && oldData.exists()) { mkdirs(data); - plugin.getLog().severe("===== Legacy Schema Migration ====="); - plugin.getLog().severe("Starting migration from legacy schema. This could take a while...."); - plugin.getLog().severe("Please do not stop your server while the migration takes place."); + this.plugin.getLog().severe("===== Legacy Schema Migration ====="); + this.plugin.getLog().severe("Starting migration from legacy schema. This could take a while...."); + this.plugin.getLog().severe("Please do not stop your server while the migration takes place."); if (this instanceof YamlDao) { try { - new LegacyYamlMigration(plugin, (YamlDao) this, oldData, data).run(); + new LegacyYamlMigration(this.plugin, (YamlDao) this, oldData, data).run(); } catch (Exception e) { e.printStackTrace(); } } else if (this instanceof JsonDao) { try { - new LegacyJsonMigration(plugin, (JsonDao) this, oldData, data).run(); + new LegacyJsonMigration(this.plugin, (JsonDao) this, oldData, data).run(); } catch (Exception e) { e.printStackTrace(); } @@ -244,69 +244,69 @@ public abstract class ConfigurateDao extends AbstractDao { mkdirs(data); } - usersDirectory = new File(data, "users"); - mkdir(usersDirectory); + this.usersDirectory = new File(data, "users"); + mkdir(this.usersDirectory); - groupsDirectory = new File(data, "groups"); - mkdir(groupsDirectory); + this.groupsDirectory = new File(data, "groups"); + mkdir(this.groupsDirectory); - tracksDirectory = new File(data, "tracks"); - mkdir(tracksDirectory); + this.tracksDirectory = new File(data, "tracks"); + mkdir(this.tracksDirectory); - uuidDataFile = new File(data, "uuidcache.txt"); - uuidDataFile.createNewFile(); + this.uuidDataFile = new File(data, "uuidcache.txt"); + this.uuidDataFile.createNewFile(); - actionLogFile = new File(data, "actions.log"); - actionLogFile.createNewFile(); + this.actionLogFile = new File(data, "actions.log"); + this.actionLogFile.createNewFile(); // Listen for file changes. - plugin.getFileWatcher().ifPresent(watcher -> { - watcher.subscribe("user", usersDirectory.toPath(), s -> { - if (!s.endsWith(fileExtension)) { + this.plugin.getFileWatcher().ifPresent(watcher -> { + watcher.subscribe("user", this.usersDirectory.toPath(), s -> { + if (!s.endsWith(this.fileExtension)) { return; } - String user = s.substring(0, s.length() - fileExtension.length()); + String user = s.substring(0, s.length() - this.fileExtension.length()); UUID uuid = CommandUtils.parseUuid(user); if (uuid == null) { return; } - User u = plugin.getUserManager().getIfLoaded(uuid); + User u = this.plugin.getUserManager().getIfLoaded(uuid); if (u != null) { - plugin.getLog().info("[FileWatcher] Refreshing user " + u.getFriendlyName()); - plugin.getStorage().loadUser(uuid, null); + this.plugin.getLog().info("[FileWatcher] Refreshing user " + u.getFriendlyName()); + this.plugin.getStorage().loadUser(uuid, null); } }); - watcher.subscribe("group", groupsDirectory.toPath(), s -> { - if (!s.endsWith(fileExtension)) { + watcher.subscribe("group", this.groupsDirectory.toPath(), s -> { + if (!s.endsWith(this.fileExtension)) { return; } - String groupName = s.substring(0, s.length() - fileExtension.length()); - plugin.getLog().info("[FileWatcher] Refreshing group " + groupName); - plugin.getUpdateTaskBuffer().request(); + String groupName = s.substring(0, s.length() - this.fileExtension.length()); + this.plugin.getLog().info("[FileWatcher] Refreshing group " + groupName); + this.plugin.getUpdateTaskBuffer().request(); }); - watcher.subscribe("track", tracksDirectory.toPath(), s -> { - if (!s.endsWith(fileExtension)) { + watcher.subscribe("track", this.tracksDirectory.toPath(), s -> { + if (!s.endsWith(this.fileExtension)) { return; } - String trackName = s.substring(0, s.length() - fileExtension.length()); - plugin.getLog().info("[FileWatcher] Refreshing track " + trackName); - plugin.getStorage().loadAllTracks(); + String trackName = s.substring(0, s.length() - this.fileExtension.length()); + this.plugin.getLog().info("[FileWatcher] Refreshing track " + trackName); + this.plugin.getStorage().loadAllTracks(); }); }); } @Override public void shutdown() { - uuidCache.save(uuidDataFile); + this.uuidCache.save(this.uuidDataFile); } @Override public void logAction(LogEntry entry) { - actionLogger.info(String.format(LOG_FORMAT, + this.actionLogger.info(String.format(LOG_FORMAT, (entry.getActor().equals(CommandManager.CONSOLE_UUID) ? "" : entry.getActor() + " "), entry.getActorName(), Character.toString(entry.getType().getCode()), @@ -379,7 +379,7 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public User loadUser(UUID uuid, String username) throws Exception { - User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); + User user = this.plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); user.getIoLock().lock(); try { ConfigurationNode object = readFile(StorageLocation.USER, uuid.toString()); @@ -391,7 +391,7 @@ public abstract class ConfigurateDao extends AbstractDao { user.setEnduringNodes(nodes); user.setName(name, true); - boolean save = plugin.getUserManager().giveDefaultIfNeeded(user, false); + boolean save = this.plugin.getUserManager().giveDefaultIfNeeded(user, false); if (user.getName().isPresent() && (name == null || !user.getName().get().equalsIgnoreCase(name))) { save = true; } @@ -403,7 +403,7 @@ public abstract class ConfigurateDao extends AbstractDao { if (GenericUserManager.shouldSave(user)) { user.clearNodes(); user.getPrimaryGroup().setStoredValue(null); - plugin.getUserManager().giveDefaultIfNeeded(user, false); + this.plugin.getUserManager().giveDefaultIfNeeded(user, false); } } } catch (Exception e) { @@ -441,10 +441,10 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public Set getUniqueUsers() { - String[] fileNames = usersDirectory.list(getFileTypeFilter()); + String[] fileNames = this.usersDirectory.list(getFileTypeFilter()); if (fileNames == null) return null; return Arrays.stream(fileNames) - .map(s -> s.substring(0, s.length() - fileExtension.length())) + .map(s -> s.substring(0, s.length() - this.fileExtension.length())) .map(UUID::fromString) .collect(Collectors.toSet()); } @@ -461,7 +461,7 @@ public abstract class ConfigurateDao extends AbstractDao { try { registerFileAction(StorageLocation.USER, file); ConfigurationNode object = readFile(file); - UUID holder = UUID.fromString(file.getName().substring(0, file.getName().length() - fileExtension.length())); + UUID holder = UUID.fromString(file.getName().substring(0, file.getName().length() - this.fileExtension.length())); Set nodes = readNodes(object); for (NodeModel e : nodes) { if (!e.getPermission().equalsIgnoreCase(permission)) { @@ -478,7 +478,7 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public Group createAndLoadGroup(String name) throws Exception { - Group group = plugin.getGroupManager().getOrMake(name); + Group group = this.plugin.getGroupManager().getOrMake(name); group.getIoLock().lock(); try { ConfigurationNode object = readFile(StorageLocation.GROUP, name); @@ -506,7 +506,7 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public Optional loadGroup(String name) throws Exception { - Group group = plugin.getGroupManager().getIfLoaded(name); + Group group = this.plugin.getGroupManager().getIfLoaded(name); if (group != null) { group.getIoLock().lock(); } @@ -519,7 +519,7 @@ public abstract class ConfigurateDao extends AbstractDao { } if (group == null) { - group = plugin.getGroupManager().getOrMake(name); + group = this.plugin.getGroupManager().getOrMake(name); group.getIoLock().lock(); } @@ -540,12 +540,12 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public void loadAllGroups() throws IOException { - String[] fileNames = groupsDirectory.list(getFileTypeFilter()); + String[] fileNames = this.groupsDirectory.list(getFileTypeFilter()); if (fileNames == null) { throw new IOException("Not a directory"); } List groups = Arrays.stream(fileNames) - .map(s -> s.substring(0, s.length() - fileExtension.length())) + .map(s -> s.substring(0, s.length() - this.fileExtension.length())) .collect(Collectors.toList()); boolean success = true; @@ -562,7 +562,7 @@ public abstract class ConfigurateDao extends AbstractDao { throw new RuntimeException("Exception occurred whilst loading a group"); } - GroupManager gm = plugin.getGroupManager(); + GroupManager gm = this.plugin.getGroupManager(); gm.getAll().values().stream() .filter(g -> !groups.contains(g.getName())) .forEach(gm::unload); @@ -590,7 +590,7 @@ public abstract class ConfigurateDao extends AbstractDao { public void deleteGroup(Group group) throws Exception { group.getIoLock().lock(); try { - File groupFile = new File(groupsDirectory, group.getName() + fileExtension); + File groupFile = new File(this.groupsDirectory, group.getName() + this.fileExtension); registerFileAction(StorageLocation.GROUP, groupFile); if (groupFile.exists()) { @@ -601,7 +601,7 @@ public abstract class ConfigurateDao extends AbstractDao { } finally { group.getIoLock().unlock(); } - plugin.getGroupManager().unload(group); + this.plugin.getGroupManager().unload(group); } @Override @@ -616,7 +616,7 @@ public abstract class ConfigurateDao extends AbstractDao { try { registerFileAction(StorageLocation.GROUP, file); ConfigurationNode object = readFile(file); - String holder = file.getName().substring(0, file.getName().length() - fileExtension.length()); + String holder = file.getName().substring(0, file.getName().length() - this.fileExtension.length()); Set nodes = readNodes(object); for (NodeModel e : nodes) { if (!e.getPermission().equalsIgnoreCase(permission)) { @@ -633,7 +633,7 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public Track createAndLoadTrack(String name) throws Exception { - Track track = plugin.getTrackManager().getOrMake(name); + Track track = this.plugin.getTrackManager().getOrMake(name); track.getIoLock().lock(); try { ConfigurationNode object = readFile(StorageLocation.TRACK, name); @@ -661,7 +661,7 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public Optional loadTrack(String name) throws Exception { - Track track = plugin.getTrackManager().getIfLoaded(name); + Track track = this.plugin.getTrackManager().getIfLoaded(name); if (track != null) { track.getIoLock().lock(); } @@ -674,7 +674,7 @@ public abstract class ConfigurateDao extends AbstractDao { } if (track == null) { - track = plugin.getTrackManager().getOrMake(name); + track = this.plugin.getTrackManager().getOrMake(name); track.getIoLock().lock(); } @@ -696,12 +696,12 @@ public abstract class ConfigurateDao extends AbstractDao { @Override public void loadAllTracks() throws IOException { - String[] fileNames = tracksDirectory.list(getFileTypeFilter()); + String[] fileNames = this.tracksDirectory.list(getFileTypeFilter()); if (fileNames == null) { throw new IOException("Not a directory"); } List tracks = Arrays.stream(fileNames) - .map(s -> s.substring(0, s.length() - fileExtension.length())) + .map(s -> s.substring(0, s.length() - this.fileExtension.length())) .collect(Collectors.toList()); boolean success = true; @@ -718,7 +718,7 @@ public abstract class ConfigurateDao extends AbstractDao { throw new RuntimeException("Exception occurred whilst loading a track"); } - TrackManager tm = plugin.getTrackManager(); + TrackManager tm = this.plugin.getTrackManager(); tm.getAll().values().stream() .filter(t -> !tracks.contains(t.getName())) .forEach(tm::unload); @@ -743,7 +743,7 @@ public abstract class ConfigurateDao extends AbstractDao { public void deleteTrack(Track track) throws Exception { track.getIoLock().lock(); try { - File trackFile = new File(tracksDirectory, track.getName() + fileExtension); + File trackFile = new File(this.tracksDirectory, track.getName() + this.fileExtension); registerFileAction(StorageLocation.TRACK, trackFile); if (trackFile.exists()) { @@ -754,22 +754,22 @@ public abstract class ConfigurateDao extends AbstractDao { } finally { track.getIoLock().unlock(); } - plugin.getTrackManager().unload(track); + this.plugin.getTrackManager().unload(track); } @Override public void saveUUIDData(UUID uuid, String username) { - uuidCache.addMapping(uuid, username); + this.uuidCache.addMapping(uuid, username); } @Override public UUID getUUID(String username) { - return uuidCache.lookupUUID(username); + return this.uuidCache.lookupUUID(username); } @Override public String getName(UUID uuid) { - return uuidCache.lookupUsername(uuid); + return this.uuidCache.lookupUsername(uuid); } private static Collection readAttributes(ConfigurationNode entry, String permission) { diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileUuidCache.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileUuidCache.java index c54954c75..ce77f064d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileUuidCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileUuidCache.java @@ -55,7 +55,7 @@ public class FileUuidCache { * @param username the username of the player */ public void addMapping(UUID uuid, String username) { - lookupMap.put(username.toLowerCase(), Maps.immutableEntry(uuid, DateUtil.unixSecondsNow())); + this.lookupMap.put(username.toLowerCase(), Maps.immutableEntry(uuid, DateUtil.unixSecondsNow())); } /** @@ -65,7 +65,7 @@ public class FileUuidCache { * @return a uuid, or null */ public UUID lookupUUID(String username) { - Map.Entry ret = lookupMap.get(username.toLowerCase()); + Map.Entry ret = this.lookupMap.get(username.toLowerCase()); return ret == null ? null : ret.getKey(); } @@ -79,7 +79,7 @@ public class FileUuidCache { String username = null; Long time = Long.MIN_VALUE; - for (Map.Entry> ent : lookupMap.entrySet()) { + for (Map.Entry> ent : this.lookupMap.entrySet()) { if (!ent.getValue().getKey().equals(uuid)) { continue; } @@ -153,7 +153,7 @@ public class FileUuidCache { t = 0L; } - lookupMap.put(key, Maps.immutableEntry(uid, t)); + this.lookupMap.put(key, Maps.immutableEntry(uid, t)); } } catch (IOException e) { @@ -166,7 +166,7 @@ public class FileUuidCache { writer.write("# LuckPerms UUID lookup cache"); writer.newLine(); - for (Map.Entry> ent : lookupMap.entrySet()) { + for (Map.Entry> ent : this.lookupMap.entrySet()) { String out = ent.getKey() + "=" + ent.getValue().getKey().toString() + "|" + ent.getValue().getValue().toString(); writer.write(out); writer.newLine(); diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileWatcher.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileWatcher.java index a525cbc11..ec1cbe9ae 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileWatcher.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/file/FileWatcher.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.storage.dao.file; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.plugin.LuckPermsPlugin; import java.io.IOException; @@ -63,20 +60,20 @@ public class FileWatcher implements Runnable { } public void subscribe(String id, Path path, Consumer consumer) { - if (watchService == null) { + if (this.watchService == null) { return; } // Register with a delay to ignore changes made at startup - plugin.getScheduler().asyncLater(() -> { + this.plugin.getScheduler().asyncLater(() -> { try { // doesn't need to be atomic - if (keyMap.containsKey(id)) { + if (this.keyMap.containsKey(id)) { throw new IllegalArgumentException("id already registered"); } - WatchKey key = path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY); - keyMap.put(id, new WatchedLocation(path, key, consumer)); + WatchKey key = path.register(this.watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY); + this.keyMap.put(id, new WatchedLocation(path, key, consumer)); } catch (IOException e) { e.printStackTrace(); } @@ -84,16 +81,16 @@ public class FileWatcher implements Runnable { } public void registerChange(StorageLocation location, String fileName) { - internalChanges.put(location.name().toLowerCase() + "/" + fileName, System.currentTimeMillis()); + this.internalChanges.put(location.name().toLowerCase() + "/" + fileName, System.currentTimeMillis()); } public void close() { - if (watchService == null) { + if (this.watchService == null) { return; } try { - watchService.close(); + this.watchService.close(); } catch (IOException e) { e.printStackTrace(); } @@ -103,11 +100,11 @@ public class FileWatcher implements Runnable { public void run() { long expireTime = System.currentTimeMillis() - TimeUnit.SECONDS.toMillis(4); // was either processed last time, or recently modified by the system. - internalChanges.values().removeIf(lastChange -> lastChange < expireTime); + this.internalChanges.values().removeIf(lastChange -> lastChange < expireTime); List expired = new ArrayList<>(); - for (Map.Entry ent : keyMap.entrySet()) { + for (Map.Entry ent : this.keyMap.entrySet()) { String id = ent.getKey(); Path path = ent.getValue().getPath(); WatchKey key = ent.getValue().getKey(); @@ -129,14 +126,14 @@ public class FileWatcher implements Runnable { continue; } - if (internalChanges.containsKey(id + "/" + fileName)) { + if (this.internalChanges.containsKey(id + "/" + fileName)) { // This file was modified by the system. continue; } - internalChanges.put(id + "/" + fileName, System.currentTimeMillis()); + this.internalChanges.put(id + "/" + fileName, System.currentTimeMillis()); - plugin.getLog().info("[FileWatcher] Detected change in file: " + file.toString()); + this.plugin.getLog().info("[FileWatcher] Detected change in file: " + file.toString()); // Process the change ent.getValue().getFileConsumer().accept(fileName); @@ -149,15 +146,31 @@ public class FileWatcher implements Runnable { } } - expired.forEach(keyMap::remove); + expired.forEach(this.keyMap::remove); } - @Getter - @RequiredArgsConstructor private static class WatchedLocation { private final Path path; private final WatchKey key; private final Consumer fileConsumer; + + public WatchedLocation(Path path, WatchKey key, Consumer fileConsumer) { + this.path = path; + this.key = key; + this.fileConsumer = fileConsumer; + } + + public Path getPath() { + return this.path; + } + + public WatchKey getKey() { + return this.key; + } + + public Consumer getFileConsumer() { + return this.fileConsumer; + } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyJsonMigration.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyJsonMigration.java index 5f7f6059a..36a6c732f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyJsonMigration.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyJsonMigration.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage.dao.legacy; -import lombok.RequiredArgsConstructor; - import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonArray; @@ -53,7 +51,6 @@ import java.util.Set; import java.util.stream.Collectors; @SuppressWarnings("unchecked") -@RequiredArgsConstructor public class LegacyJsonMigration implements Runnable { private final Gson gson = new GsonBuilder().setPrettyPrinting().create(); @@ -62,21 +59,28 @@ public class LegacyJsonMigration implements Runnable { private final File oldDataFolder; private final File newDataFolder; + public LegacyJsonMigration(LuckPermsPlugin plugin, JsonDao backing, File oldDataFolder, File newDataFolder) { + this.plugin = plugin; + this.backing = backing; + this.oldDataFolder = oldDataFolder; + this.newDataFolder = newDataFolder; + } + private void writeElementToFile(File file, JsonElement element) { try (BufferedWriter writer = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8)) { - gson.toJson(element, writer); + this.gson.toJson(element, writer); writer.flush(); } catch (Throwable t) { - plugin.getLog().warn("Exception whilst writing to file: " + file.getAbsolutePath()); + this.plugin.getLog().warn("Exception whilst writing to file: " + file.getAbsolutePath()); t.printStackTrace(); } } private JsonObject readObjectFromFile(File file) { try (BufferedReader reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8)) { - return gson.fromJson(reader, JsonObject.class); + return this.gson.fromJson(reader, JsonObject.class); } catch (Throwable t) { - plugin.getLog().warn("Exception whilst reading from file: " + file.getAbsolutePath()); + this.plugin.getLog().warn("Exception whilst reading from file: " + file.getAbsolutePath()); t.printStackTrace(); return null; } @@ -84,18 +88,18 @@ public class LegacyJsonMigration implements Runnable { @Override public void run() { - plugin.getLog().warn("Moving existing files to their new location."); - relocateFile(oldDataFolder, newDataFolder, "actions.log"); - relocateFile(oldDataFolder, newDataFolder, "uuidcache.txt"); - relocateFile(oldDataFolder, newDataFolder, "tracks"); + this.plugin.getLog().warn("Moving existing files to their new location."); + relocateFile(this.oldDataFolder, this.newDataFolder, "actions.log"); + relocateFile(this.oldDataFolder, this.newDataFolder, "uuidcache.txt"); + relocateFile(this.oldDataFolder, this.newDataFolder, "tracks"); - plugin.getLog().warn("Migrating group files"); - File oldGroupsDir = new File(oldDataFolder, "groups"); + this.plugin.getLog().warn("Migrating group files"); + File oldGroupsDir = new File(this.oldDataFolder, "groups"); if (oldGroupsDir.exists() && oldGroupsDir.isDirectory()) { - File newGroupsDir = new File(newDataFolder, "groups"); + File newGroupsDir = new File(this.newDataFolder, "groups"); newGroupsDir.mkdir(); - File[] toMigrate = oldGroupsDir.listFiles((dir, name) -> name.endsWith(backing.getFileExtension())); + File[] toMigrate = oldGroupsDir.listFiles((dir, name) -> name.endsWith(this.backing.getFileExtension())); if (toMigrate != null) { for (File oldFile : toMigrate) { try { @@ -137,14 +141,14 @@ public class LegacyJsonMigration implements Runnable { } } - plugin.getLog().warn("Migrated group files, now migrating user files."); + this.plugin.getLog().warn("Migrated group files, now migrating user files."); - File oldUsersDir = new File(oldDataFolder, "users"); + File oldUsersDir = new File(this.oldDataFolder, "users"); if (oldUsersDir.exists() && oldUsersDir.isDirectory()) { - File newUsersDir = new File(newDataFolder, "users"); + File newUsersDir = new File(this.newDataFolder, "users"); newUsersDir.mkdir(); - File[] toMigrate = oldUsersDir.listFiles((dir, name) -> name.endsWith(backing.getFileExtension())); + File[] toMigrate = oldUsersDir.listFiles((dir, name) -> name.endsWith(this.backing.getFileExtension())); if (toMigrate != null) { for (File oldFile : toMigrate) { try { @@ -188,12 +192,12 @@ public class LegacyJsonMigration implements Runnable { } } } - plugin.getLog().warn("Migrated user files."); + this.plugin.getLog().warn("Migrated user files."); // rename the old data file - oldDataFolder.renameTo(new File(oldDataFolder.getParent(), "old-data-backup")); + this.oldDataFolder.renameTo(new File(this.oldDataFolder.getParent(), "old-data-backup")); - plugin.getLog().warn("Legacy schema migration complete."); + this.plugin.getLog().warn("Legacy schema migration complete."); } private static void relocateFile(File dirFrom, File dirTo, String fileName) { diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacySqlMigration.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacySqlMigration.java index 8e95fed57..69bedcfcd 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacySqlMigration.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacySqlMigration.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage.dao.legacy; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.Lists; import com.google.gson.reflect.TypeToken; @@ -51,17 +49,20 @@ import java.util.UUID; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Collectors; -@RequiredArgsConstructor public class LegacySqlMigration implements Runnable { private static final Type NODE_MAP_TYPE = new TypeToken>() {}.getType(); private final SqlDao backing; + public LegacySqlMigration(SqlDao backing) { + this.backing = backing; + } + @Override public void run() { - backing.getPlugin().getLog().warn("Collecting UUID data from the old tables."); + this.backing.getPlugin().getLog().warn("Collecting UUID data from the old tables."); Map uuidData = new HashMap<>(); - try (Connection c = backing.getProvider().getConnection()) { + try (Connection c = this.backing.getProvider().getConnection()) { try (PreparedStatement ps = c.prepareStatement("SELECT uuid, name FROM lp_uuid")) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { @@ -77,14 +78,14 @@ public class LegacySqlMigration implements Runnable { e.printStackTrace(); } - backing.getPlugin().getLog().warn("Found " + uuidData.size() + " uuid data entries. Copying to new tables..."); + this.backing.getPlugin().getLog().warn("Found " + uuidData.size() + " uuid data entries. Copying to new tables..."); List> uuidEntries = new ArrayList<>(uuidData.entrySet()); List>> partitionedUuidEntries = Lists.partition(uuidEntries, 100); for (List> l : partitionedUuidEntries) { - try (Connection c = backing.getProvider().getConnection()) { - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("INSERT INTO {prefix}players VALUES(?, ?, ?)"))) { + try (Connection c = this.backing.getProvider().getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("INSERT INTO {prefix}players VALUES(?, ?, ?)"))) { for (Map.Entry e : l) { ps.setString(1, e.getKey().toString()); ps.setString(2, e.getValue().toLowerCase()); @@ -102,11 +103,11 @@ public class LegacySqlMigration implements Runnable { uuidEntries.clear(); partitionedUuidEntries.clear(); - backing.getPlugin().getLog().warn("Migrated all uuid data."); - backing.getPlugin().getLog().warn("Starting user data migration."); + this.backing.getPlugin().getLog().warn("Migrated all uuid data."); + this.backing.getPlugin().getLog().warn("Starting user data migration."); Set users = new HashSet<>(); - try (Connection c = backing.getProvider().getConnection()) { + try (Connection c = this.backing.getProvider().getConnection()) { try (PreparedStatement ps = c.prepareStatement("SELECT uuid FROM lp_users")) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { @@ -122,14 +123,14 @@ public class LegacySqlMigration implements Runnable { e.printStackTrace(); } - backing.getPlugin().getLog().warn("Found " + users.size() + " user data entries. Copying to new tables..."); + this.backing.getPlugin().getLog().warn("Found " + users.size() + " user data entries. Copying to new tables..."); AtomicInteger userCounter = new AtomicInteger(0); for (UUID uuid : users) { String permsJson = null; String primaryGroup = null; - try (Connection c = backing.getProvider().getConnection()) { + try (Connection c = this.backing.getProvider().getConnection()) { try (PreparedStatement ps = c.prepareStatement("SELECT primary_group, perms FROM lp_users WHERE uuid=?")) { ps.setString(1, uuid.toString()); try (ResultSet rs = ps.executeQuery()) { @@ -148,7 +149,7 @@ public class LegacySqlMigration implements Runnable { continue; } - Map convertedPerms = backing.getGson().fromJson(permsJson, NODE_MAP_TYPE); + Map convertedPerms = this.backing.getGson().fromJson(permsJson, NODE_MAP_TYPE); if (convertedPerms == null) { new Throwable().printStackTrace(); continue; @@ -159,8 +160,8 @@ public class LegacySqlMigration implements Runnable { .map(NodeModel::fromNode) .collect(Collectors.toSet()); - try (Connection c = backing.getProvider().getConnection()) { - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("INSERT INTO {prefix}user_permissions(uuid, permission, value, server, world, expiry, contexts) VALUES(?, ?, ?, ?, ?, ?, ?)"))) { + try (Connection c = this.backing.getProvider().getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("INSERT INTO {prefix}user_permissions(uuid, permission, value, server, world, expiry, contexts) VALUES(?, ?, ?, ?, ?, ?, ?)"))) { for (NodeModel nd : nodes) { ps.setString(1, uuid.toString()); ps.setString(2, nd.getPermission()); @@ -168,7 +169,7 @@ public class LegacySqlMigration implements Runnable { ps.setString(4, nd.getServer()); ps.setString(5, nd.getWorld()); ps.setLong(6, nd.getExpiry()); - ps.setString(7, backing.getGson().toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); + ps.setString(7, this.backing.getGson().toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); ps.addBatch(); } ps.executeBatch(); @@ -178,8 +179,8 @@ public class LegacySqlMigration implements Runnable { } if (!primaryGroup.equalsIgnoreCase(NodeFactory.DEFAULT_GROUP_NAME)) { - try (Connection c = backing.getProvider().getConnection()) { - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("UPDATE {prefix}players SET primary_group=? WHERE uuid=?"))) { + try (Connection c = this.backing.getProvider().getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("UPDATE {prefix}players SET primary_group=? WHERE uuid=?"))) { ps.setString(1, primaryGroup); ps.setString(2, uuid.toString()); ps.execute(); @@ -191,17 +192,17 @@ public class LegacySqlMigration implements Runnable { int i = userCounter.incrementAndGet(); if (i % 100 == 0) { - backing.getPlugin().getLog().warn("Migrated " + i + " users so far..."); + this.backing.getPlugin().getLog().warn("Migrated " + i + " users so far..."); } } users.clear(); - backing.getPlugin().getLog().warn("Migrated all user data."); - backing.getPlugin().getLog().warn("Starting group data migration."); + this.backing.getPlugin().getLog().warn("Migrated all user data."); + this.backing.getPlugin().getLog().warn("Starting group data migration."); Map groupData = new HashMap<>(); - try (Connection c = backing.getProvider().getConnection()) { + try (Connection c = this.backing.getProvider().getConnection()) { try (PreparedStatement ps = c.prepareStatement("SELECT name, perms FROM lp_groups")) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { @@ -213,13 +214,13 @@ public class LegacySqlMigration implements Runnable { e.printStackTrace(); } - backing.getPlugin().getLog().warn("Found " + groupData.size() + " group data entries. Copying to new tables..."); + this.backing.getPlugin().getLog().warn("Found " + groupData.size() + " group data entries. Copying to new tables..."); for (Map.Entry e : groupData.entrySet()) { String name = e.getKey(); String permsJson = e.getValue(); - try (Connection c = backing.getProvider().getConnection()) { - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("INSERT INTO {prefix}groups VALUES(?)"))) { + try (Connection c = this.backing.getProvider().getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("INSERT INTO {prefix}groups VALUES(?)"))) { ps.setString(1, name); ps.execute(); } @@ -227,7 +228,7 @@ public class LegacySqlMigration implements Runnable { ex.printStackTrace(); } - Map convertedPerms = backing.getGson().fromJson(permsJson, NODE_MAP_TYPE); + Map convertedPerms = this.backing.getGson().fromJson(permsJson, NODE_MAP_TYPE); if (convertedPerms == null) { new Throwable().printStackTrace(); continue; @@ -238,8 +239,8 @@ public class LegacySqlMigration implements Runnable { .map(NodeModel::fromNode) .collect(Collectors.toSet()); - try (Connection c = backing.getProvider().getConnection()) { - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("INSERT INTO {prefix}group_permissions(name, permission, value, server, world, expiry, contexts) VALUES(?, ?, ?, ?, ?, ?, ?)"))) { + try (Connection c = this.backing.getProvider().getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("INSERT INTO {prefix}group_permissions(name, permission, value, server, world, expiry, contexts) VALUES(?, ?, ?, ?, ?, ?, ?)"))) { for (NodeModel nd : nodes) { ps.setString(1, name); ps.setString(2, nd.getPermission()); @@ -247,7 +248,7 @@ public class LegacySqlMigration implements Runnable { ps.setString(4, nd.getServer()); ps.setString(5, nd.getWorld()); ps.setLong(6, nd.getExpiry()); - ps.setString(7, backing.getGson().toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); + ps.setString(7, this.backing.getGson().toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); ps.addBatch(); } ps.executeBatch(); @@ -258,27 +259,27 @@ public class LegacySqlMigration implements Runnable { } groupData.clear(); - backing.getPlugin().getLog().warn("Migrated all group data."); + this.backing.getPlugin().getLog().warn("Migrated all group data."); - backing.getPlugin().getLog().warn("Renaming action and track tables."); - try (Connection c = backing.getProvider().getConnection()) { - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("DROP TABLE {prefix}actions"))) { + this.backing.getPlugin().getLog().warn("Renaming action and track tables."); + try (Connection c = this.backing.getProvider().getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("DROP TABLE {prefix}actions"))) { ps.execute(); } - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("ALTER TABLE lp_actions RENAME TO {prefix}actions"))) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("ALTER TABLE lp_actions RENAME TO {prefix}actions"))) { ps.execute(); } - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("DROP TABLE {prefix}tracks"))) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("DROP TABLE {prefix}tracks"))) { ps.execute(); } - try (PreparedStatement ps = c.prepareStatement(backing.getPrefix().apply("ALTER TABLE lp_tracks RENAME TO {prefix}tracks"))) { + try (PreparedStatement ps = c.prepareStatement(this.backing.getPrefix().apply("ALTER TABLE lp_tracks RENAME TO {prefix}tracks"))) { ps.execute(); } } catch (SQLException ex) { ex.printStackTrace(); } - backing.getPlugin().getLog().warn("Legacy schema migration complete."); + this.backing.getPlugin().getLog().warn("Legacy schema migration complete."); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyYamlMigration.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyYamlMigration.java index fb72f2bac..f8c3a0ccd 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyYamlMigration.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/legacy/LegacyYamlMigration.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage.dao.legacy; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.node.LegacyNodeFactory; import me.lucko.luckperms.common.node.NodeModel; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; @@ -52,7 +50,6 @@ import java.util.Set; import java.util.stream.Collectors; @SuppressWarnings("unchecked") -@RequiredArgsConstructor public class LegacyYamlMigration implements Runnable { private final LuckPermsPlugin plugin; private final YamlDao backing; @@ -68,21 +65,28 @@ public class LegacyYamlMigration implements Runnable { return new Yaml(options); } + public LegacyYamlMigration(LuckPermsPlugin plugin, YamlDao backing, File oldDataFolder, File newDataFolder) { + this.plugin = plugin; + this.backing = backing; + this.oldDataFolder = oldDataFolder; + this.newDataFolder = newDataFolder; + } + public void writeMapToFile(File file, Map values) { try (BufferedWriter writer = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8)) { - yaml.dump(values, writer); + this.yaml.dump(values, writer); writer.flush(); } catch (Throwable t) { - plugin.getLog().warn("Exception whilst writing to file: " + file.getAbsolutePath()); + this.plugin.getLog().warn("Exception whilst writing to file: " + file.getAbsolutePath()); t.printStackTrace(); } } public Map readMapFromFile(File file) { try (BufferedReader reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8)) { - return (Map) yaml.load(reader); + return (Map) this.yaml.load(reader); } catch (Throwable t) { - plugin.getLog().warn("Exception whilst reading from file: " + file.getAbsolutePath()); + this.plugin.getLog().warn("Exception whilst reading from file: " + file.getAbsolutePath()); t.printStackTrace(); return null; } @@ -90,18 +94,18 @@ public class LegacyYamlMigration implements Runnable { @Override public void run() { - plugin.getLog().warn("Moving existing files to their new location."); - relocateFile(oldDataFolder, newDataFolder, "actions.log"); - relocateFile(oldDataFolder, newDataFolder, "uuidcache.txt"); - relocateFile(oldDataFolder, newDataFolder, "tracks"); + this.plugin.getLog().warn("Moving existing files to their new location."); + relocateFile(this.oldDataFolder, this.newDataFolder, "actions.log"); + relocateFile(this.oldDataFolder, this.newDataFolder, "uuidcache.txt"); + relocateFile(this.oldDataFolder, this.newDataFolder, "tracks"); - plugin.getLog().warn("Migrating group files"); - File oldGroupsDir = new File(oldDataFolder, "groups"); + this.plugin.getLog().warn("Migrating group files"); + File oldGroupsDir = new File(this.oldDataFolder, "groups"); if (oldGroupsDir.exists() && oldGroupsDir.isDirectory()) { - File newGroupsDir = new File(newDataFolder, "groups"); + File newGroupsDir = new File(this.newDataFolder, "groups"); newGroupsDir.mkdir(); - File[] toMigrate = oldGroupsDir.listFiles((dir, name) -> name.endsWith(backing.getFileExtension())); + File[] toMigrate = oldGroupsDir.listFiles((dir, name) -> name.endsWith(this.backing.getFileExtension())); if (toMigrate != null) { for (File oldFile : toMigrate) { try { @@ -138,14 +142,14 @@ public class LegacyYamlMigration implements Runnable { } } - plugin.getLog().warn("Migrated group files, now migrating user files."); + this.plugin.getLog().warn("Migrated group files, now migrating user files."); - File oldUsersDir = new File(oldDataFolder, "users"); + File oldUsersDir = new File(this.oldDataFolder, "users"); if (oldUsersDir.exists() && oldUsersDir.isDirectory()) { - File newUsersDir = new File(newDataFolder, "users"); + File newUsersDir = new File(this.newDataFolder, "users"); newUsersDir.mkdir(); - File[] toMigrate = oldUsersDir.listFiles((dir, name) -> name.endsWith(backing.getFileExtension())); + File[] toMigrate = oldUsersDir.listFiles((dir, name) -> name.endsWith(this.backing.getFileExtension())); if (toMigrate != null) { for (File oldFile : toMigrate) { try { @@ -185,12 +189,12 @@ public class LegacyYamlMigration implements Runnable { } } } - plugin.getLog().warn("Migrated user files."); + this.plugin.getLog().warn("Migrated user files."); // rename the old data file - oldDataFolder.renameTo(new File(oldDataFolder.getParent(), "old-data-backup")); + this.oldDataFolder.renameTo(new File(this.oldDataFolder.getParent(), "old-data-backup")); - plugin.getLog().warn("Legacy schema migration complete."); + this.plugin.getLog().warn("Legacy schema migration complete."); } private static void relocateFile(File dirFrom, File dirTo, String fileName) { diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/mongodb/MongoDao.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/mongodb/MongoDao.java index c67e2f76f..60214dec4 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/mongodb/MongoDao.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/mongodb/MongoDao.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage.dao.mongodb; -import lombok.Getter; - import com.google.common.base.Strings; import com.google.common.collect.ImmutableList; import com.mongodb.MongoClient; @@ -80,8 +78,6 @@ public class MongoDao extends AbstractDao { private final StorageCredentials configuration; private MongoClient mongoClient; private MongoDatabase database; - - @Getter private final String prefix; public MongoDao(LuckPermsPlugin plugin, StorageCredentials configuration, String prefix) { @@ -93,32 +89,32 @@ public class MongoDao extends AbstractDao { @Override public void init() { MongoCredential credential = null; - if (!Strings.isNullOrEmpty(configuration.getUsername())) { + if (!Strings.isNullOrEmpty(this.configuration.getUsername())) { credential = MongoCredential.createCredential( - configuration.getUsername(), - configuration.getDatabase(), - Strings.isNullOrEmpty(configuration.getPassword()) ? null : configuration.getPassword().toCharArray() + this.configuration.getUsername(), + this.configuration.getDatabase(), + Strings.isNullOrEmpty(this.configuration.getPassword()) ? null : this.configuration.getPassword().toCharArray() ); } - String[] addressSplit = configuration.getAddress().split(":"); + String[] addressSplit = this.configuration.getAddress().split(":"); String host = addressSplit[0]; int port = addressSplit.length > 1 ? Integer.parseInt(addressSplit[1]) : 27017; ServerAddress address = new ServerAddress(host, port); if (credential == null) { - mongoClient = new MongoClient(address, Collections.emptyList()); + this.mongoClient = new MongoClient(address, Collections.emptyList()); } else { - mongoClient = new MongoClient(address, Collections.singletonList(credential)); + this.mongoClient = new MongoClient(address, Collections.singletonList(credential)); } - database = mongoClient.getDatabase(configuration.getDatabase()); + this.database = this.mongoClient.getDatabase(this.configuration.getDatabase()); } @Override public void shutdown() { - if (mongoClient != null) { - mongoClient.close(); + if (this.mongoClient != null) { + this.mongoClient.close(); } } @@ -129,7 +125,7 @@ public class MongoDao extends AbstractDao { long start = System.currentTimeMillis(); try { - database.runCommand(new Document("ping", 1)); + this.database.runCommand(new Document("ping", 1)); } catch (Exception e) { success = false; } @@ -147,7 +143,7 @@ public class MongoDao extends AbstractDao { @Override public void logAction(LogEntry entry) { - MongoCollection c = database.getCollection(prefix + "action"); + MongoCollection c = this.database.getCollection(this.prefix + "action"); Document doc = new Document() .append("timestamp", entry.getTimestamp()) .append("actor", entry.getActor()) @@ -166,7 +162,7 @@ public class MongoDao extends AbstractDao { @Override public Log getLog() { Log.Builder log = Log.builder(); - MongoCollection c = database.getCollection(prefix + "action"); + MongoCollection c = this.database.getCollection(this.prefix + "action"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { Document d = cursor.next(); @@ -195,7 +191,7 @@ public class MongoDao extends AbstractDao { @Override public void applyBulkUpdate(BulkUpdate bulkUpdate) { if (bulkUpdate.getDataType().isIncludingUsers()) { - MongoCollection c = database.getCollection(prefix + "users"); + MongoCollection c = this.database.getCollection(this.prefix + "users"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { Document d = cursor.next(); @@ -220,7 +216,7 @@ public class MongoDao extends AbstractDao { } if (bulkUpdate.getDataType().isIncludingGroups()) { - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { Document d = cursor.next(); @@ -247,10 +243,10 @@ public class MongoDao extends AbstractDao { @Override public User loadUser(UUID uuid, String username) { - User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); + User user = this.plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); user.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "users"); + MongoCollection c = this.database.getCollection(this.prefix + "users"); try (MongoCursor cursor = c.find(new Document("_id", user.getUuid())).iterator()) { if (cursor.hasNext()) { // User exists, let's load. @@ -263,7 +259,7 @@ public class MongoDao extends AbstractDao { user.setEnduringNodes(nodes); user.setName(name, true); - boolean save = plugin.getUserManager().giveDefaultIfNeeded(user, false); + boolean save = this.plugin.getUserManager().giveDefaultIfNeeded(user, false); if (user.getName().isPresent() && (name == null || !user.getName().get().equalsIgnoreCase(name))) { save = true; } @@ -275,7 +271,7 @@ public class MongoDao extends AbstractDao { if (GenericUserManager.shouldSave(user)) { user.clearNodes(); user.getPrimaryGroup().setStoredValue(null); - plugin.getUserManager().giveDefaultIfNeeded(user, false); + this.plugin.getUserManager().giveDefaultIfNeeded(user, false); } } } @@ -290,7 +286,7 @@ public class MongoDao extends AbstractDao { public void saveUser(User user) { user.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "users"); + MongoCollection c = this.database.getCollection(this.prefix + "users"); if (!GenericUserManager.shouldSave(user)) { c.deleteOne(new Document("_id", user.getUuid())); } else { @@ -304,7 +300,7 @@ public class MongoDao extends AbstractDao { @Override public Set getUniqueUsers() { Set uuids = new HashSet<>(); - MongoCollection c = database.getCollection(prefix + "users"); + MongoCollection c = this.database.getCollection(this.prefix + "users"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { Document d = cursor.next(); @@ -317,7 +313,7 @@ public class MongoDao extends AbstractDao { @Override public List> getUsersWithPermission(String permission) { ImmutableList.Builder> held = ImmutableList.builder(); - MongoCollection c = database.getCollection(prefix + "users"); + MongoCollection c = this.database.getCollection(this.prefix + "users"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { Document d = cursor.next(); @@ -337,10 +333,10 @@ public class MongoDao extends AbstractDao { @Override public Group createAndLoadGroup(String name) { - Group group = plugin.getGroupManager().getOrMake(name); + Group group = this.plugin.getGroupManager().getOrMake(name); group.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); try (MongoCursor cursor = c.find(new Document("_id", group.getName())).iterator()) { if (cursor.hasNext()) { Document d = cursor.next(); @@ -359,19 +355,19 @@ public class MongoDao extends AbstractDao { @Override public Optional loadGroup(String name) { - Group group = plugin.getGroupManager().getIfLoaded(name); + Group group = this.plugin.getGroupManager().getIfLoaded(name); if (group != null) { group.getIoLock().lock(); } try { - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); try (MongoCursor cursor = c.find(new Document("_id", name)).iterator()) { if (!cursor.hasNext()) { return Optional.empty(); } if (group == null) { - group = plugin.getGroupManager().getOrMake(name); + group = this.plugin.getGroupManager().getOrMake(name); group.getIoLock().lock(); } @@ -391,7 +387,7 @@ public class MongoDao extends AbstractDao { @Override public void loadAllGroups() { List groups = new ArrayList<>(); - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { String name = cursor.next().getString("_id"); @@ -413,7 +409,7 @@ public class MongoDao extends AbstractDao { throw new RuntimeException("Exception occurred whilst loading a group"); } - GroupManager gm = plugin.getGroupManager(); + GroupManager gm = this.plugin.getGroupManager(); gm.getAll().values().stream() .filter(g -> !groups.contains(g.getName())) .forEach(gm::unload); @@ -423,7 +419,7 @@ public class MongoDao extends AbstractDao { public void saveGroup(Group group) { group.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); c.replaceOne(new Document("_id", group.getName()), groupToDoc(group), new UpdateOptions().upsert(true)); } finally { group.getIoLock().unlock(); @@ -434,7 +430,7 @@ public class MongoDao extends AbstractDao { public void deleteGroup(Group group) { group.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); c.deleteOne(new Document("_id", group.getName())); } finally { group.getIoLock().unlock(); @@ -444,7 +440,7 @@ public class MongoDao extends AbstractDao { @Override public List> getGroupsWithPermission(String permission) { ImmutableList.Builder> held = ImmutableList.builder(); - MongoCollection c = database.getCollection(prefix + "groups"); + MongoCollection c = this.database.getCollection(this.prefix + "groups"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { Document d = cursor.next(); @@ -464,10 +460,10 @@ public class MongoDao extends AbstractDao { @Override public Track createAndLoadTrack(String name) { - Track track = plugin.getTrackManager().getOrMake(name); + Track track = this.plugin.getTrackManager().getOrMake(name); track.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "tracks"); + MongoCollection c = this.database.getCollection(this.prefix + "tracks"); try (MongoCursor cursor = c.find(new Document("_id", track.getName())).iterator()) { if (!cursor.hasNext()) { c.insertOne(trackToDoc(track)); @@ -485,20 +481,20 @@ public class MongoDao extends AbstractDao { @Override public Optional loadTrack(String name) { - Track track = plugin.getTrackManager().getIfLoaded(name); + Track track = this.plugin.getTrackManager().getIfLoaded(name); if (track != null) { track.getIoLock().lock(); } try { - MongoCollection c = database.getCollection(prefix + "tracks"); + MongoCollection c = this.database.getCollection(this.prefix + "tracks"); try (MongoCursor cursor = c.find(new Document("_id", name)).iterator()) { if (!cursor.hasNext()) { return Optional.empty(); } if (track == null) { - track = plugin.getTrackManager().getOrMake(name); + track = this.plugin.getTrackManager().getOrMake(name); track.getIoLock().lock(); } @@ -517,7 +513,7 @@ public class MongoDao extends AbstractDao { @Override public void loadAllTracks() { List tracks = new ArrayList<>(); - MongoCollection c = database.getCollection(prefix + "tracks"); + MongoCollection c = this.database.getCollection(this.prefix + "tracks"); try (MongoCursor cursor = c.find().iterator()) { while (cursor.hasNext()) { String name = cursor.next().getString("_id"); @@ -539,7 +535,7 @@ public class MongoDao extends AbstractDao { throw new RuntimeException("Exception occurred whilst loading a track"); } - TrackManager tm = plugin.getTrackManager(); + TrackManager tm = this.plugin.getTrackManager(); tm.getAll().values().stream() .filter(t -> !tracks.contains(t.getName())) .forEach(tm::unload); @@ -549,7 +545,7 @@ public class MongoDao extends AbstractDao { public void saveTrack(Track track) { track.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "tracks"); + MongoCollection c = this.database.getCollection(this.prefix + "tracks"); c.replaceOne(new Document("_id", track.getName()), trackToDoc(track)); } finally { track.getIoLock().unlock(); @@ -560,7 +556,7 @@ public class MongoDao extends AbstractDao { public void deleteTrack(Track track) { track.getIoLock().lock(); try { - MongoCollection c = database.getCollection(prefix + "tracks"); + MongoCollection c = this.database.getCollection(this.prefix + "tracks"); c.deleteOne(new Document("_id", track.getName())); } finally { track.getIoLock().unlock(); @@ -569,13 +565,13 @@ public class MongoDao extends AbstractDao { @Override public void saveUUIDData(UUID uuid, String username) { - MongoCollection c = database.getCollection(prefix + "uuid"); + MongoCollection c = this.database.getCollection(this.prefix + "uuid"); c.replaceOne(new Document("_id", uuid), new Document("_id", uuid).append("name", username.toLowerCase()), new UpdateOptions().upsert(true)); } @Override public UUID getUUID(String username) { - MongoCollection c = database.getCollection(prefix + "uuid"); + MongoCollection c = this.database.getCollection(this.prefix + "uuid"); try (MongoCursor cursor = c.find(new Document("name", username.toLowerCase())).iterator()) { if (cursor.hasNext()) { return cursor.next().get("_id", UUID.class); @@ -586,7 +582,7 @@ public class MongoDao extends AbstractDao { @Override public String getName(UUID uuid) { - MongoCollection c = database.getCollection(prefix + "uuid"); + MongoCollection c = this.database.getCollection(this.prefix + "uuid"); try (MongoCursor cursor = c.find(new Document("_id", uuid)).iterator()) { if (cursor.hasNext()) { return cursor.next().get("name", String.class); diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/SqlDao.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/SqlDao.java index 677953f9b..34320da72 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/SqlDao.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/SqlDao.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.storage.dao.sql; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import com.google.common.collect.Maps; import com.google.gson.Gson; @@ -120,24 +118,33 @@ public class SqlDao extends AbstractDao { private static final String ACTION_SELECT_ALL = "SELECT * FROM {prefix}actions"; - @Getter private final Gson gson; - @Getter private final AbstractConnectionFactory provider; - @Getter private final Function prefix; public SqlDao(LuckPermsPlugin plugin, AbstractConnectionFactory provider, String prefix) { super(plugin, provider.getName()); this.provider = provider; this.prefix = s -> s.replace("{prefix}", prefix); - gson = new Gson(); + this.gson = new Gson(); + } + + public Gson getGson() { + return this.gson; + } + + public AbstractConnectionFactory getProvider() { + return this.provider; + } + + public Function getPrefix() { + return this.prefix; } private boolean tableExists(String table) throws SQLException { - try (Connection connection = provider.getConnection()) { + try (Connection connection = this.provider.getConnection()) { try (ResultSet rs = connection.getMetaData().getTables(null, null, "%", null)) { while (rs.next()) { if (rs.getString(3).equalsIgnoreCase(table)) { @@ -152,18 +159,18 @@ public class SqlDao extends AbstractDao { @Override public void init() { try { - provider.init(); + this.provider.init(); // Init tables - if (!tableExists(prefix.apply("{prefix}user_permissions"))) { - String schemaFileName = "schema/" + provider.getName().toLowerCase() + ".sql"; - try (InputStream is = plugin.getResourceStream(schemaFileName)) { + if (!tableExists(this.prefix.apply("{prefix}user_permissions"))) { + String schemaFileName = "schema/" + this.provider.getName().toLowerCase() + ".sql"; + try (InputStream is = this.plugin.getResourceStream(schemaFileName)) { if (is == null) { - throw new Exception("Couldn't locate schema file for " + provider.getName()); + throw new Exception("Couldn't locate schema file for " + this.provider.getName()); } try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) { - try (Connection connection = provider.getConnection()) { + try (Connection connection = this.provider.getConnection()) { try (Statement s = connection.createStatement()) { StringBuilder sb = new StringBuilder(); String line; @@ -176,7 +183,7 @@ public class SqlDao extends AbstractDao { if (line.endsWith(";")) { sb.deleteCharAt(sb.length() - 1); - String result = prefix.apply(sb.toString().trim()); + String result = this.prefix.apply(sb.toString().trim()); if (!result.isEmpty()) s.addBatch(result); // reset @@ -191,26 +198,26 @@ public class SqlDao extends AbstractDao { // Try migration from legacy backing if (tableExists("lp_users")) { - plugin.getLog().severe("===== Legacy Schema Migration ====="); - plugin.getLog().severe("Starting migration from legacy schema. This could take a while...."); - plugin.getLog().severe("Please do not stop your server while the migration takes place."); + this.plugin.getLog().severe("===== Legacy Schema Migration ====="); + this.plugin.getLog().severe("Starting migration from legacy schema. This could take a while...."); + this.plugin.getLog().severe("Please do not stop your server while the migration takes place."); new LegacySqlMigration(this).run(); } } // migrations - if (!(provider instanceof SQLiteConnectionFactory) && !(provider instanceof PostgreConnectionFactory)) { - try (Connection connection = provider.getConnection()) { + if (!(this.provider instanceof SQLiteConnectionFactory) && !(this.provider instanceof PostgreConnectionFactory)) { + try (Connection connection = this.provider.getConnection()) { try (Statement s = connection.createStatement()) { - s.execute(prefix.apply("ALTER TABLE {prefix}actions MODIFY COLUMN actor_name VARCHAR(100)")); - s.execute(prefix.apply("ALTER TABLE {prefix}actions MODIFY COLUMN action VARCHAR(300)")); + s.execute(this.prefix.apply("ALTER TABLE {prefix}actions MODIFY COLUMN actor_name VARCHAR(100)")); + s.execute(this.prefix.apply("ALTER TABLE {prefix}actions MODIFY COLUMN action VARCHAR(300)")); } } } } catch (Exception e) { - plugin.getLog().severe("Error occurred whilst initialising the database."); + this.plugin.getLog().severe("Error occurred whilst initialising the database."); e.printStackTrace(); } } @@ -218,7 +225,7 @@ public class SqlDao extends AbstractDao { @Override public void shutdown() { try { - provider.shutdown(); + this.provider.shutdown(); } catch (Exception e) { e.printStackTrace(); } @@ -226,13 +233,13 @@ public class SqlDao extends AbstractDao { @Override public Map getMeta() { - return provider.getMeta(); + return this.provider.getMeta(); } @Override public void logAction(LogEntry entry) throws SQLException { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(ACTION_INSERT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(ACTION_INSERT))) { ps.setLong(1, entry.getTimestamp()); ps.setString(2, entry.getActor().toString()); ps.setString(3, entry.getActorName()); @@ -248,8 +255,8 @@ public class SqlDao extends AbstractDao { @Override public Log getLog() throws SQLException { final Log.Builder log = Log.builder(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(ACTION_SELECT_ALL))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(ACTION_SELECT_ALL))) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { final String actedUuid = rs.getString("acted_uuid"); @@ -275,16 +282,16 @@ public class SqlDao extends AbstractDao { public void applyBulkUpdate(BulkUpdate bulkUpdate) throws SQLException { String queryString = bulkUpdate.buildAsSql(); - try (Connection c = provider.getConnection()) { + try (Connection c = this.provider.getConnection()) { if (bulkUpdate.getDataType().isIncludingUsers()) { - String table = prefix.apply("{prefix}user_permissions"); + String table = this.prefix.apply("{prefix}user_permissions"); try (Statement s = c.createStatement()) { s.execute(queryString.replace("{table}", table)); } } if (bulkUpdate.getDataType().isIncludingGroups()) { - String table = prefix.apply("{prefix}group_permissions"); + String table = this.prefix.apply("{prefix}group_permissions"); try (Statement s = c.createStatement()) { s.execute(queryString.replace("{table}", table)); } @@ -294,7 +301,7 @@ public class SqlDao extends AbstractDao { @Override public User loadUser(UUID uuid, String username) throws SQLException { - User user = plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); + User user = this.plugin.getUserManager().getOrMake(UserIdentifier.of(uuid, username)); user.getIoLock().lock(); try { List data = new ArrayList<>(); @@ -302,8 +309,8 @@ public class SqlDao extends AbstractDao { AtomicReference userName = new AtomicReference<>(null); // Collect user permissions - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_SELECT))) { ps.setString(1, user.getUuid().toString()); try (ResultSet rs = ps.executeQuery()) { @@ -321,8 +328,8 @@ public class SqlDao extends AbstractDao { } // Collect user meta (username & primary group) - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_SELECT))) { ps.setString(1, user.getUuid().toString()); try (ResultSet rs = ps.executeQuery()) { @@ -350,7 +357,7 @@ public class SqlDao extends AbstractDao { user.setEnduringNodes(nodes); // Save back to the store if data was changed - if (plugin.getUserManager().giveDefaultIfNeeded(user, false)) { + if (this.plugin.getUserManager().giveDefaultIfNeeded(user, false)) { // This should be fine, as the lock will be acquired by the same thread. saveUser(user); } @@ -360,7 +367,7 @@ public class SqlDao extends AbstractDao { if (GenericUserManager.shouldSave(user)) { user.clearNodes(); user.getPrimaryGroup().setStoredValue(null); - plugin.getUserManager().giveDefaultIfNeeded(user, false); + this.plugin.getUserManager().giveDefaultIfNeeded(user, false); } } } finally { @@ -376,12 +383,12 @@ public class SqlDao extends AbstractDao { try { // Empty data - just delete from the DB. if (!GenericUserManager.shouldSave(user)) { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_DELETE))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_DELETE))) { ps.setString(1, user.getUuid().toString()); ps.execute(); } - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_UPDATE_PRIMARY_GROUP))) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_UPDATE_PRIMARY_GROUP))) { ps.setString(1, NodeFactory.DEFAULT_GROUP_NAME); ps.setString(2, user.getUuid().toString()); ps.execute(); @@ -392,8 +399,8 @@ public class SqlDao extends AbstractDao { // Get a snapshot of current data. Set remote = new HashSet<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_SELECT))) { ps.setString(1, user.getUuid().toString()); try (ResultSet rs = ps.executeQuery()) { @@ -418,8 +425,8 @@ public class SqlDao extends AbstractDao { Set toRemove = diff.getValue(); if (!toRemove.isEmpty()) { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_DELETE_SPECIFIC))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_DELETE_SPECIFIC))) { for (NodeModel nd : toRemove) { ps.setString(1, user.getUuid().toString()); ps.setString(2, nd.getPermission()); @@ -427,7 +434,7 @@ public class SqlDao extends AbstractDao { ps.setString(4, nd.getServer()); ps.setString(5, nd.getWorld()); ps.setLong(6, nd.getExpiry()); - ps.setString(7, gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); + ps.setString(7, this.gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); ps.addBatch(); } ps.executeBatch(); @@ -436,8 +443,8 @@ public class SqlDao extends AbstractDao { } if (!toAdd.isEmpty()) { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_INSERT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_INSERT))) { for (NodeModel nd : toAdd) { ps.setString(1, user.getUuid().toString()); ps.setString(2, nd.getPermission()); @@ -445,7 +452,7 @@ public class SqlDao extends AbstractDao { ps.setString(4, nd.getServer()); ps.setString(5, nd.getWorld()); ps.setLong(6, nd.getExpiry()); - ps.setString(7, gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); + ps.setString(7, this.gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); ps.addBatch(); } ps.executeBatch(); @@ -453,10 +460,10 @@ public class SqlDao extends AbstractDao { } } - try (Connection c = provider.getConnection()) { + try (Connection c = this.provider.getConnection()) { boolean hasPrimaryGroupSaved; - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_SELECT_PRIMARY_GROUP))) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_SELECT_PRIMARY_GROUP))) { ps.setString(1, user.getUuid().toString()); try (ResultSet rs = ps.executeQuery()) { hasPrimaryGroupSaved = rs.next(); @@ -465,14 +472,14 @@ public class SqlDao extends AbstractDao { if (hasPrimaryGroupSaved) { // update - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_UPDATE_PRIMARY_GROUP))) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_UPDATE_PRIMARY_GROUP))) { ps.setString(1, user.getPrimaryGroup().getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME)); ps.setString(2, user.getUuid().toString()); ps.execute(); } } else { // insert - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_INSERT))) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_INSERT))) { ps.setString(1, user.getUuid().toString()); ps.setString(2, user.getName().orElse("null")); ps.setString(3, user.getPrimaryGroup().getStoredValue().orElse(NodeFactory.DEFAULT_GROUP_NAME)); @@ -489,8 +496,8 @@ public class SqlDao extends AbstractDao { @Override public Set getUniqueUsers() throws SQLException { Set uuids = new HashSet<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_SELECT_DISTINCT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_SELECT_DISTINCT))) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { String uuid = rs.getString("uuid"); @@ -505,8 +512,8 @@ public class SqlDao extends AbstractDao { @Override public List> getUsersWithPermission(String permission) throws SQLException { ImmutableList.Builder> held = ImmutableList.builder(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(USER_PERMISSIONS_SELECT_PERMISSION))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(USER_PERMISSIONS_SELECT_PERMISSION))) { ps.setString(1, permission); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { @@ -529,7 +536,7 @@ public class SqlDao extends AbstractDao { @Override public Group createAndLoadGroup(String name) throws SQLException { String query; - switch (provider.getName()) { + switch (this.provider.getName()) { case "H2": query = H2_GROUP_INSERT; break; @@ -544,8 +551,8 @@ public class SqlDao extends AbstractDao { break; } - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(query))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(query))) { ps.setString(1, name); ps.execute(); } @@ -558,8 +565,8 @@ public class SqlDao extends AbstractDao { public Optional loadGroup(String name) throws SQLException { // Check the group actually exists List groups = new ArrayList<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_SELECT_ALL))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_SELECT_ALL))) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { groups.add(rs.getString("name").toLowerCase()); @@ -573,13 +580,13 @@ public class SqlDao extends AbstractDao { return Optional.empty(); } - Group group = plugin.getGroupManager().getOrMake(name); + Group group = this.plugin.getGroupManager().getOrMake(name); group.getIoLock().lock(); try { List data = new ArrayList<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_SELECT))) { ps.setString(1, group.getName()); try (ResultSet rs = ps.executeQuery()) { @@ -612,8 +619,8 @@ public class SqlDao extends AbstractDao { @Override public void loadAllGroups() throws SQLException { List groups = new ArrayList<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_SELECT_ALL))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_SELECT_ALL))) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { groups.add(rs.getString("name").toLowerCase()); @@ -636,7 +643,7 @@ public class SqlDao extends AbstractDao { throw new RuntimeException("Exception occurred whilst loading a group"); } - GroupManager gm = plugin.getGroupManager(); + GroupManager gm = this.plugin.getGroupManager(); gm.getAll().values().stream() .filter(g -> !groups.contains(g.getName())) .forEach(gm::unload); @@ -648,8 +655,8 @@ public class SqlDao extends AbstractDao { try { // Empty data, just delete. if (group.getEnduringNodes().isEmpty()) { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_DELETE))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_DELETE))) { ps.setString(1, group.getName()); ps.execute(); } @@ -659,8 +666,8 @@ public class SqlDao extends AbstractDao { // Get a snapshot of current data Set remote = new HashSet<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_SELECT))) { ps.setString(1, group.getName()); try (ResultSet rs = ps.executeQuery()) { @@ -685,8 +692,8 @@ public class SqlDao extends AbstractDao { Set toRemove = diff.getValue(); if (!toRemove.isEmpty()) { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_DELETE_SPECIFIC))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_DELETE_SPECIFIC))) { for (NodeModel nd : toRemove) { ps.setString(1, group.getName()); ps.setString(2, nd.getPermission()); @@ -694,7 +701,7 @@ public class SqlDao extends AbstractDao { ps.setString(4, nd.getServer()); ps.setString(5, nd.getWorld()); ps.setLong(6, nd.getExpiry()); - ps.setString(7, gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); + ps.setString(7, this.gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); ps.addBatch(); } ps.executeBatch(); @@ -703,8 +710,8 @@ public class SqlDao extends AbstractDao { } if (!toAdd.isEmpty()) { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_INSERT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_INSERT))) { for (NodeModel nd : toAdd) { ps.setString(1, group.getName()); ps.setString(2, nd.getPermission()); @@ -712,7 +719,7 @@ public class SqlDao extends AbstractDao { ps.setString(4, nd.getServer()); ps.setString(5, nd.getWorld()); ps.setLong(6, nd.getExpiry()); - ps.setString(7, gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); + ps.setString(7, this.gson.toJson(ContextSetJsonSerializer.serializeContextSet(nd.getContexts()))); ps.addBatch(); } ps.executeBatch(); @@ -728,13 +735,13 @@ public class SqlDao extends AbstractDao { public void deleteGroup(Group group) throws SQLException { group.getIoLock().lock(); try { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_DELETE))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_DELETE))) { ps.setString(1, group.getName()); ps.execute(); } - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_DELETE))) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_DELETE))) { ps.setString(1, group.getName()); ps.execute(); } @@ -743,14 +750,14 @@ public class SqlDao extends AbstractDao { group.getIoLock().unlock(); } - plugin.getGroupManager().unload(group); + this.plugin.getGroupManager().unload(group); } @Override public List> getGroupsWithPermission(String permission) throws SQLException { ImmutableList.Builder> held = ImmutableList.builder(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(GROUP_PERMISSIONS_SELECT_PERMISSION))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(GROUP_PERMISSIONS_SELECT_PERMISSION))) { ps.setString(1, permission); try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { @@ -772,14 +779,14 @@ public class SqlDao extends AbstractDao { @Override public Track createAndLoadTrack(String name) throws SQLException { - Track track = plugin.getTrackManager().getOrMake(name); + Track track = this.plugin.getTrackManager().getOrMake(name); track.getIoLock().lock(); try { AtomicBoolean exists = new AtomicBoolean(false); AtomicReference groups = new AtomicReference<>(null); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(TRACK_SELECT))) { ps.setString(1, track.getName()); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -792,11 +799,11 @@ public class SqlDao extends AbstractDao { if (exists.get()) { // Track exists, let's load. - track.setGroups(gson.fromJson(groups.get(), LIST_STRING_TYPE)); + track.setGroups(this.gson.fromJson(groups.get(), LIST_STRING_TYPE)); } else { - String json = gson.toJson(track.getGroups()); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_INSERT))) { + String json = this.gson.toJson(track.getGroups()); + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(TRACK_INSERT))) { ps.setString(1, track.getName()); ps.setString(2, json); ps.execute(); @@ -811,15 +818,15 @@ public class SqlDao extends AbstractDao { @Override public Optional loadTrack(String name) throws SQLException { - Track track = plugin.getTrackManager().getIfLoaded(name); + Track track = this.plugin.getTrackManager().getIfLoaded(name); if (track != null) { track.getIoLock().lock(); } try { AtomicReference groups = new AtomicReference<>(null); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(TRACK_SELECT))) { ps.setString(1, name); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -832,11 +839,11 @@ public class SqlDao extends AbstractDao { } if (track == null) { - track = plugin.getTrackManager().getOrMake(name); + track = this.plugin.getTrackManager().getOrMake(name); track.getIoLock().lock(); } - track.setGroups(gson.fromJson(groups.get(), LIST_STRING_TYPE)); + track.setGroups(this.gson.fromJson(groups.get(), LIST_STRING_TYPE)); return Optional.of(track); } finally { @@ -849,8 +856,8 @@ public class SqlDao extends AbstractDao { @Override public void loadAllTracks() throws SQLException { List tracks = new ArrayList<>(); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_SELECT_ALL))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(TRACK_SELECT_ALL))) { try (ResultSet rs = ps.executeQuery()) { while (rs.next()) { tracks.add(rs.getString("name").toLowerCase()); @@ -873,7 +880,7 @@ public class SqlDao extends AbstractDao { throw new RuntimeException("Exception occurred whilst loading a track"); } - TrackManager tm = plugin.getTrackManager(); + TrackManager tm = this.plugin.getTrackManager(); tm.getAll().values().stream() .filter(t -> !tracks.contains(t.getName())) .forEach(tm::unload); @@ -883,9 +890,9 @@ public class SqlDao extends AbstractDao { public void saveTrack(Track track) throws SQLException { track.getIoLock().lock(); try { - String s = gson.toJson(track.getGroups()); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_UPDATE))) { + String s = this.gson.toJson(track.getGroups()); + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(TRACK_UPDATE))) { ps.setString(1, s); ps.setString(2, track.getName()); ps.execute(); @@ -900,8 +907,8 @@ public class SqlDao extends AbstractDao { public void deleteTrack(Track track) throws SQLException { track.getIoLock().lock(); try { - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(TRACK_DELETE))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(TRACK_DELETE))) { ps.setString(1, track.getName()); ps.execute(); } @@ -910,7 +917,7 @@ public class SqlDao extends AbstractDao { track.getIoLock().unlock(); } - plugin.getTrackManager().unload(track); + this.plugin.getTrackManager().unload(track); } @Override @@ -919,16 +926,16 @@ public class SqlDao extends AbstractDao { AtomicReference remoteUserName = new AtomicReference<>(null); // cleanup any old values - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_DELETE))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_DELETE))) { ps.setString(1, u); ps.setString(2, uuid.toString()); ps.execute(); } } - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_SELECT_USERNAME))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_SELECT_USERNAME))) { ps.setString(1, uuid.toString()); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -944,8 +951,8 @@ public class SqlDao extends AbstractDao { return; } - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_UPDATE))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_UPDATE))) { ps.setString(1, u); ps.setString(2, uuid.toString()); ps.execute(); @@ -953,8 +960,8 @@ public class SqlDao extends AbstractDao { } } else { // first time we've seen this uuid - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_INSERT))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_INSERT))) { ps.setString(1, uuid.toString()); ps.setString(2, u); ps.setString(3, NodeFactory.DEFAULT_GROUP_NAME); @@ -969,8 +976,8 @@ public class SqlDao extends AbstractDao { final String u = username.toLowerCase(); final AtomicReference uuid = new AtomicReference<>(null); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_SELECT_UUID))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_SELECT_UUID))) { ps.setString(1, u); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -987,8 +994,8 @@ public class SqlDao extends AbstractDao { public String getName(UUID uuid) throws SQLException { final AtomicReference name = new AtomicReference<>(null); - try (Connection c = provider.getConnection()) { - try (PreparedStatement ps = c.prepareStatement(prefix.apply(PLAYER_SELECT_USERNAME))) { + try (Connection c = this.provider.getConnection()) { + try (PreparedStatement ps = c.prepareStatement(this.prefix.apply(PLAYER_SELECT_USERNAME))) { ps.setString(1, uuid.toString()); try (ResultSet rs = ps.executeQuery()) { if (rs.next()) { @@ -1021,6 +1028,6 @@ public class SqlDao extends AbstractDao { } private NodeModel deserializeNode(String permission, boolean value, String server, String world, long expiry, String contexts) { - return NodeModel.of(permission, value, server, world, expiry, ContextSetJsonSerializer.deserializeContextSet(gson, contexts).makeImmutable()); + return NodeModel.of(permission, value, server, world, expiry, ContextSetJsonSerializer.deserializeContextSet(this.gson, contexts).makeImmutable()); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/AbstractConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/AbstractConnectionFactory.java index 5094b8d5c..c35090055 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/AbstractConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/AbstractConnectionFactory.java @@ -25,20 +25,23 @@ package me.lucko.luckperms.common.storage.dao.sql.connection; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import java.sql.Connection; import java.sql.SQLException; import java.util.Collections; import java.util.Map; -@RequiredArgsConstructor public abstract class AbstractConnectionFactory { - @Getter private final String name; + public AbstractConnectionFactory(String name) { + this.name = name; + } + + public String getName() { + return this.name; + } + public abstract void init(); public abstract void shutdown() throws Exception; diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/FlatfileConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/FlatfileConnectionFactory.java index f4574c3cf..29ea7a60c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/FlatfileConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/FlatfileConnectionFactory.java @@ -56,28 +56,28 @@ abstract class FlatfileConnectionFactory extends AbstractConnectionFactory { @Override public void shutdown() throws Exception { - if (connection != null) { - connection.shutdown(); + if (this.connection != null) { + this.connection.shutdown(); } } @Override public Connection getConnection() throws SQLException { - lock.lock(); + this.lock.lock(); try { if (this.connection == null || this.connection.isClosed()) { try { Class.forName(getDriverClass()); } catch (ClassNotFoundException ignored) {} - Connection connection = DriverManager.getConnection(getDriverId() + ":" + file.getAbsolutePath()); + Connection connection = DriverManager.getConnection(getDriverId() + ":" + this.file.getAbsolutePath()); if (connection != null) { this.connection = new NonClosableConnection(connection); } } } finally { - lock.unlock(); + this.lock.unlock(); } if (this.connection == null) { diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/NonClosableConnection.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/NonClosableConnection.java index b37151072..d93a6406b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/NonClosableConnection.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/file/NonClosableConnection.java @@ -25,28 +25,305 @@ package me.lucko.luckperms.common.storage.dao.sql.connection.file; -import lombok.AllArgsConstructor; -import lombok.experimental.Delegate; - +import java.sql.Array; +import java.sql.Blob; +import java.sql.CallableStatement; +import java.sql.Clob; import java.sql.Connection; +import java.sql.DatabaseMetaData; +import java.sql.NClob; +import java.sql.PreparedStatement; import java.sql.SQLException; +import java.sql.SQLWarning; +import java.sql.SQLXML; +import java.sql.Savepoint; +import java.sql.Statement; +import java.sql.Struct; +import java.util.Map; +import java.util.Properties; +import java.util.concurrent.Executor; -@AllArgsConstructor public final class NonClosableConnection implements Connection { + private final Connection delegate; - @Delegate(excludes = Exclude.class) - private Connection delegate; + public NonClosableConnection(Connection delegate) { + this.delegate = delegate; + } @Override - public void close() throws SQLException { + public void close() { } public void shutdown() throws SQLException { - delegate.close(); + this.delegate.close(); } - private interface Exclude { - void close() throws SQLException; + // delegate + + @Override + public String getCatalog() throws SQLException { + return this.delegate.getCatalog(); } + + @Override + public void commit() throws SQLException { + this.delegate.commit(); + } + + @Override + public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { + return this.delegate.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability); + } + + @Override + public String nativeSQL(String sql) throws SQLException { + return this.delegate.nativeSQL(sql); + } + + @Override + public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException { + return this.delegate.prepareStatement(sql, autoGeneratedKeys); + } + + @Override + public Blob createBlob() throws SQLException { + return this.delegate.createBlob(); + } + + @Override + public Struct createStruct(String typeName, Object[] attributes) throws SQLException { + return this.delegate.createStruct(typeName, attributes); + } + + @Override + public int getTransactionIsolation() throws SQLException { + return this.delegate.getTransactionIsolation(); + } + + @Override + public boolean isWrapperFor(Class iface) throws SQLException { + return this.delegate.isWrapperFor(iface); + } + + @Override + public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { + return this.delegate.prepareStatement(sql, resultSetType, resultSetConcurrency); + } + + @Override + public void setHoldability(int holdability) throws SQLException { + this.delegate.setHoldability(holdability); + } + + @Override + public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException { + return this.delegate.prepareStatement(sql, columnIndexes); + } + + @Override + public void setSchema(String schema) throws SQLException { + this.delegate.setSchema(schema); + } + + @Override + public void abort(Executor executor) throws SQLException { + this.delegate.abort(executor); + } + + @Override + public void setTypeMap(Map> map) throws SQLException { + this.delegate.setTypeMap(map); + } + + @Override + public NClob createNClob() throws SQLException { + return this.delegate.createNClob(); + } + + @Override + public boolean isReadOnly() throws SQLException { + return this.delegate.isReadOnly(); + } + + @Override + public boolean getAutoCommit() throws SQLException { + return this.delegate.getAutoCommit(); + } + + @Override + public int getHoldability() throws SQLException { + return this.delegate.getHoldability(); + } + + @Override + public T unwrap(Class iface) throws SQLException { + return this.delegate.unwrap(iface); + } + + @Override + public Statement createStatement() throws SQLException { + return this.delegate.createStatement(); + } + + @Override + public SQLXML createSQLXML() throws SQLException { + return this.delegate.createSQLXML(); + } + + @Override + public boolean isClosed() throws SQLException { + return this.delegate.isClosed(); + } + + @Override + public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { + return this.delegate.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability); + } + + @Override + public Properties getClientInfo() throws SQLException { + return this.delegate.getClientInfo(); + } + + @Override + public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException { + this.delegate.setNetworkTimeout(executor, milliseconds); + } + + @Override + public String getSchema() throws SQLException { + return this.delegate.getSchema(); + } + + @Override + public String getClientInfo(String name) throws SQLException { + return this.delegate.getClientInfo(name); + } + + @Override + public Array createArrayOf(String typeName, Object[] elements) throws SQLException { + return this.delegate.createArrayOf(typeName, elements); + } + + @Override + public void rollback() throws SQLException { + this.delegate.rollback(); + } + + @Override + public boolean isValid(int timeout) throws SQLException { + return this.delegate.isValid(timeout); + } + + @Override + public void rollback(Savepoint savepoint) throws SQLException { + this.delegate.rollback(savepoint); + } + + @Override + public void releaseSavepoint(Savepoint savepoint) throws SQLException { + this.delegate.releaseSavepoint(savepoint); + } + + @Override + public CallableStatement prepareCall(String sql) throws SQLException { + return this.delegate.prepareCall(sql); + } + + @Override + public int getNetworkTimeout() throws SQLException { + return this.delegate.getNetworkTimeout(); + } + + @Override + public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException { + return this.delegate.createStatement(resultSetType, resultSetConcurrency); + } + + @Override + public void setReadOnly(boolean readOnly) throws SQLException { + this.delegate.setReadOnly(readOnly); + } + + @Override + public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException { + return this.delegate.prepareStatement(sql, columnNames); + } + + @Override + public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { + return this.delegate.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability); + } + + @Override + public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { + return this.delegate.prepareCall(sql, resultSetType, resultSetConcurrency); + } + + @Override + public void setClientInfo(String name, String value) throws java.sql.SQLClientInfoException { + this.delegate.setClientInfo(name, value); + } + + @Override + public Savepoint setSavepoint() throws SQLException { + return this.delegate.setSavepoint(); + } + + @Override + public Savepoint setSavepoint(String name) throws SQLException { + return this.delegate.setSavepoint(name); + } + + @Override + public Clob createClob() throws SQLException { + return this.delegate.createClob(); + } + + @Override + public PreparedStatement prepareStatement(String sql) throws SQLException { + return this.delegate.prepareStatement(sql); + } + + @Override + public Map> getTypeMap() throws SQLException { + return this.delegate.getTypeMap(); + } + + @Override + public void setAutoCommit(boolean autoCommit) throws SQLException { + this.delegate.setAutoCommit(autoCommit); + } + + @Override + public void setClientInfo(Properties properties) throws java.sql.SQLClientInfoException { + this.delegate.setClientInfo(properties); + } + + @Override + public SQLWarning getWarnings() throws SQLException { + return this.delegate.getWarnings(); + } + + @Override + public void setTransactionIsolation(int level) throws SQLException { + this.delegate.setTransactionIsolation(level); + } + + @Override + public DatabaseMetaData getMetaData() throws SQLException { + return this.delegate.getMetaData(); + } + + @Override + public void setCatalog(String catalog) throws SQLException { + this.delegate.setCatalog(catalog); + } + + @Override + public void clearWarnings() throws SQLException { + this.delegate.clearWarnings(); + } + } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/HikariConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/HikariConnectionFactory.java index 734846e2f..f8aea26e1 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/HikariConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/HikariConnectionFactory.java @@ -59,7 +59,7 @@ public abstract class HikariConnectionFactory extends AbstractConnectionFactory } protected void appendConfigurationInfo(HikariConfig config) { - String address = configuration.getAddress(); + String address = this.configuration.getAddress(); String[] addressSplit = address.split(":"); address = addressSplit[0]; String port = addressSplit.length > 1 ? addressSplit[1] : "3306"; @@ -67,9 +67,9 @@ public abstract class HikariConnectionFactory extends AbstractConnectionFactory config.setDataSourceClassName(getDriverClass()); config.addDataSourceProperty("serverName", address); config.addDataSourceProperty("port", port); - config.addDataSourceProperty("databaseName", configuration.getDatabase()); - config.setUsername(configuration.getUsername()); - config.setPassword(configuration.getPassword()); + config.addDataSourceProperty("databaseName", this.configuration.getDatabase()); + config.setUsername(this.configuration.getUsername()); + config.setPassword(this.configuration.getPassword()); } @Override @@ -78,12 +78,12 @@ public abstract class HikariConnectionFactory extends AbstractConnectionFactory config.setPoolName("luckperms"); appendConfigurationInfo(config); - appendProperties(config, configuration); + appendProperties(config, this.configuration); - config.setMaximumPoolSize(configuration.getMaxPoolSize()); - config.setMinimumIdle(configuration.getMinIdleConnections()); - config.setMaxLifetime(configuration.getMaxLifetime()); - config.setConnectionTimeout(configuration.getConnectionTimeout()); + config.setMaximumPoolSize(this.configuration.getMaxPoolSize()); + config.setMinimumIdle(this.configuration.getMinIdleConnections()); + config.setMaxLifetime(this.configuration.getMaxLifetime()); + config.setConnectionTimeout(this.configuration.getConnectionTimeout()); // If a connection is not returned within 10 seconds, it's probably safe to assume it's been leaked. config.setLeakDetectionThreshold(TimeUnit.SECONDS.toMillis(10)); // 10000 @@ -101,13 +101,13 @@ public abstract class HikariConnectionFactory extends AbstractConnectionFactory } - hikari = new HikariDataSource(config); + this.hikari = new HikariDataSource(config); } @Override - public void shutdown() throws Exception { - if (hikari != null) { - hikari.close(); + public void shutdown() { + if (this.hikari != null) { + this.hikari.close(); } } @@ -117,7 +117,7 @@ public abstract class HikariConnectionFactory extends AbstractConnectionFactory boolean success = true; long start = System.currentTimeMillis(); - try (Connection c = hikari.getConnection()) { + try (Connection c = this.hikari.getConnection()) { try (Statement s = c.createStatement()) { s.execute("/* ping */ SELECT 1"); } @@ -138,7 +138,7 @@ public abstract class HikariConnectionFactory extends AbstractConnectionFactory @Override public Connection getConnection() throws SQLException { - Connection connection = hikari.getConnection(); + Connection connection = this.hikari.getConnection(); if (connection == null) { throw new SQLException("Unable to get a connection from the pool."); } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/MySqlConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/MySqlConnectionFactory.java index df6f65e8c..7251e502b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/MySqlConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/MySqlConnectionFactory.java @@ -36,15 +36,15 @@ public class MySqlConnectionFactory extends HikariConnectionFactory { @Override protected void appendConfigurationInfo(HikariConfig config) { - String address = configuration.getAddress(); + String address = this.configuration.getAddress(); String[] addressSplit = address.split(":"); address = addressSplit[0]; String port = addressSplit.length > 1 ? addressSplit[1] : "3306"; - String database = configuration.getDatabase(); + String database = this.configuration.getDatabase(); config.setJdbcUrl("jdbc:mysql://" + address + ":" + port + "/" + database); - config.setUsername(configuration.getUsername()); - config.setPassword(configuration.getPassword()); + config.setUsername(this.configuration.getUsername()); + config.setPassword(this.configuration.getPassword()); } @Override diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/PostgreConnectionFactory.java b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/PostgreConnectionFactory.java index 570fb04e1..b43b9fe41 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/PostgreConnectionFactory.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/dao/sql/connection/hikari/PostgreConnectionFactory.java @@ -36,14 +36,14 @@ public class PostgreConnectionFactory extends HikariConnectionFactory { @Override protected void appendConfigurationInfo(HikariConfig config) { - String address = configuration.getAddress(); + String address = this.configuration.getAddress(); String[] addressSplit = address.split(":"); address = addressSplit[0]; String port = addressSplit.length > 1 ? addressSplit[1] : "5432"; - String database = configuration.getDatabase(); - String username = configuration.getUsername(); - String password = configuration.getPassword(); + String database = this.configuration.getDatabase(); + String username = this.configuration.getUsername(); + String password = this.configuration.getPassword(); config.setDataSourceClassName("org.postgresql.ds.PGSimpleDataSource"); config.addDataSourceProperty("serverName", address); diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/BufferedOutputStorage.java b/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/BufferedOutputStorage.java index e5dc9f7ef..ed3b7f77d 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/BufferedOutputStorage.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/BufferedOutputStorage.java @@ -25,25 +25,31 @@ package me.lucko.luckperms.common.storage.wrappings; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; -import lombok.experimental.Delegate; - +import me.lucko.luckperms.api.HeldPermission; +import me.lucko.luckperms.api.LogEntry; +import me.lucko.luckperms.api.event.cause.CreationCause; +import me.lucko.luckperms.api.event.cause.DeletionCause; +import me.lucko.luckperms.common.actionlog.Log; +import me.lucko.luckperms.common.api.delegates.model.ApiStorage; import me.lucko.luckperms.common.buffers.Buffer; +import me.lucko.luckperms.common.bulkupdate.BulkUpdate; import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.model.Track; import me.lucko.luckperms.common.model.User; import me.lucko.luckperms.common.storage.Storage; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.UUID; import java.util.concurrent.CompletableFuture; -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) public class BufferedOutputStorage implements Storage, Runnable { public static BufferedOutputStorage wrap(Storage storage, long flushTime) { return new BufferedOutputStorage(storage, flushTime); } - @Delegate(excludes = Exclude.class) private final Storage delegate; private final long flushTime; @@ -52,9 +58,14 @@ public class BufferedOutputStorage implements Storage, Runnable { private final Buffer groupOutputBuffer = Buffer.of(group -> BufferedOutputStorage.this.delegate.saveGroup(group).join()); private final Buffer trackOutputBuffer = Buffer.of(track -> BufferedOutputStorage.this.delegate.saveTrack(track).join()); + private BufferedOutputStorage(Storage delegate, long flushTime) { + this.delegate = delegate; + this.flushTime = flushTime; + } + @Override public void run() { - flush(flushTime); + flush(this.flushTime); } public void forceFlush() { @@ -62,42 +73,147 @@ public class BufferedOutputStorage implements Storage, Runnable { } public void flush(long flushTime) { - userOutputBuffer.flush(flushTime); - groupOutputBuffer.flush(flushTime); - trackOutputBuffer.flush(flushTime); + this.userOutputBuffer.flush(flushTime); + this.groupOutputBuffer.flush(flushTime); + this.trackOutputBuffer.flush(flushTime); } @Override public Storage noBuffer() { - return delegate; + return this.delegate; } @Override public void shutdown() { forceFlush(); - delegate.shutdown(); + this.delegate.shutdown(); } @Override public CompletableFuture saveUser(User user) { - return userOutputBuffer.enqueue(user); + return this.userOutputBuffer.enqueue(user); } @Override public CompletableFuture saveGroup(Group group) { - return groupOutputBuffer.enqueue(group); + return this.groupOutputBuffer.enqueue(group); } @Override public CompletableFuture saveTrack(Track track) { - return trackOutputBuffer.enqueue(track); + return this.trackOutputBuffer.enqueue(track); } - private interface Exclude { - Storage noBuffer(); - void shutdown(); - CompletableFuture saveUser(User user); - CompletableFuture saveGroup(Group group); - CompletableFuture saveTrack(Track track); + // delegate + + @Override + public CompletableFuture> getUniqueUsers() { + return this.delegate.getUniqueUsers(); } + + @Override + public CompletableFuture> loadTrack(String name) { + return this.delegate.loadTrack(name); + } + + @Override + public CompletableFuture>> getUsersWithPermission(String permission) { + return this.delegate.getUsersWithPermission(permission); + } + + @Override + public CompletableFuture>> getGroupsWithPermission(String permission) { + return this.delegate.getGroupsWithPermission(permission); + } + + @Override + public CompletableFuture applyBulkUpdate(BulkUpdate bulkUpdate) { + return this.delegate.applyBulkUpdate(bulkUpdate); + } + + @Override + public CompletableFuture saveUUIDData(UUID uuid, String username) { + return this.delegate.saveUUIDData(uuid, username); + } + + @Override + public CompletableFuture createAndLoadGroup(String name, CreationCause cause) { + return this.delegate.createAndLoadGroup(name, cause); + } + + @Override + public Map getMeta() { + return this.delegate.getMeta(); + } + + @Override + public CompletableFuture deleteGroup(Group group, DeletionCause cause) { + return this.delegate.deleteGroup(group, cause); + } + + @Override + public CompletableFuture getUUID(String username) { + return this.delegate.getUUID(username); + } + + @Override + public CompletableFuture loadUser(UUID uuid, String username) { + return this.delegate.loadUser(uuid, username); + } + + @Override + public CompletableFuture createAndLoadTrack(String name, CreationCause cause) { + return this.delegate.createAndLoadTrack(name, cause); + } + + @Override + public CompletableFuture getLog() { + return this.delegate.getLog(); + } + + @Override + public ApiStorage getDelegate() { + return this.delegate.getDelegate(); + } + + @Override + public CompletableFuture getName(UUID uuid) { + return this.delegate.getName(uuid); + } + + @Override + public String getName() { + return this.delegate.getName(); + } + + @Override + public CompletableFuture loadAllTracks() { + return this.delegate.loadAllTracks(); + } + + @Override + public void init() { + this.delegate.init(); + } + + @Override + public CompletableFuture deleteTrack(Track track, DeletionCause cause) { + return this.delegate.deleteTrack(track, cause); + } + + @Override + public CompletableFuture logAction(LogEntry entry) { + return this.delegate.logAction(entry); + } + + @Override + public CompletableFuture loadAllGroups() { + return this.delegate.loadAllGroups(); + } + + @Override + public CompletableFuture> loadGroup(String name) { + return this.delegate.loadGroup(name); + } + } diff --git a/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/PhasedStorage.java b/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/PhasedStorage.java index bc82209cd..09141bbdf 100644 --- a/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/PhasedStorage.java +++ b/common/src/main/java/me/lucko/luckperms/common/storage/wrappings/PhasedStorage.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.storage.wrappings; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.HeldPermission; import me.lucko.luckperms.api.LogEntry; import me.lucko.luckperms.api.event.cause.CreationCause; @@ -53,24 +50,26 @@ import java.util.concurrent.TimeoutException; /** * A Datastore wrapping that ensures all tasks are completed before {@link Storage#shutdown()} is called. */ -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) public class PhasedStorage implements Storage { public static PhasedStorage wrap(Storage storage) { return new PhasedStorage(storage); } private final Storage delegate; - private final Phaser phaser = new Phaser(); + private PhasedStorage(Storage delegate) { + this.delegate = delegate; + } + @Override public ApiStorage getDelegate() { - return delegate.getDelegate(); + return this.delegate.getDelegate(); } @Override public String getName() { - return delegate.getName(); + return this.delegate.getName(); } @Override @@ -80,233 +79,233 @@ public class PhasedStorage implements Storage { @Override public void init() { - delegate.init(); + this.delegate.init(); } @Override public void shutdown() { // Wait for other threads to finish. try { - phaser.awaitAdvanceInterruptibly(phaser.getPhase(), 10, TimeUnit.SECONDS); + this.phaser.awaitAdvanceInterruptibly(this.phaser.getPhase(), 10, TimeUnit.SECONDS); } catch (InterruptedException | TimeoutException e) { e.printStackTrace(); } - delegate.shutdown(); + this.delegate.shutdown(); } @Override public Map getMeta() { - return delegate.getMeta(); + return this.delegate.getMeta(); } @Override public CompletableFuture logAction(LogEntry entry) { - phaser.register(); + this.phaser.register(); try { - return delegate.logAction(entry); + return this.delegate.logAction(entry); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture getLog() { - phaser.register(); + this.phaser.register(); try { - return delegate.getLog(); + return this.delegate.getLog(); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture applyBulkUpdate(BulkUpdate bulkUpdate) { - phaser.register(); + this.phaser.register(); try { - return delegate.applyBulkUpdate(bulkUpdate); + return this.delegate.applyBulkUpdate(bulkUpdate); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture loadUser(UUID uuid, String username) { - phaser.register(); + this.phaser.register(); try { - return delegate.loadUser(uuid, username); + return this.delegate.loadUser(uuid, username); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture saveUser(User user) { - phaser.register(); + this.phaser.register(); try { - return delegate.saveUser(user); + return this.delegate.saveUser(user); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture> getUniqueUsers() { - phaser.register(); + this.phaser.register(); try { - return delegate.getUniqueUsers(); + return this.delegate.getUniqueUsers(); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture>> getUsersWithPermission(String permission) { - phaser.register(); + this.phaser.register(); try { - return delegate.getUsersWithPermission(permission); + return this.delegate.getUsersWithPermission(permission); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture createAndLoadGroup(String name, CreationCause cause) { - phaser.register(); + this.phaser.register(); try { - return delegate.createAndLoadGroup(name, cause); + return this.delegate.createAndLoadGroup(name, cause); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture> loadGroup(String name) { - phaser.register(); + this.phaser.register(); try { - return delegate.loadGroup(name); + return this.delegate.loadGroup(name); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture loadAllGroups() { - phaser.register(); + this.phaser.register(); try { - return delegate.loadAllGroups(); + return this.delegate.loadAllGroups(); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture saveGroup(Group group) { - phaser.register(); + this.phaser.register(); try { - return delegate.saveGroup(group); + return this.delegate.saveGroup(group); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture deleteGroup(Group group, DeletionCause cause) { - phaser.register(); + this.phaser.register(); try { - return delegate.deleteGroup(group, cause); + return this.delegate.deleteGroup(group, cause); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture>> getGroupsWithPermission(String permission) { - phaser.register(); + this.phaser.register(); try { - return delegate.getGroupsWithPermission(permission); + return this.delegate.getGroupsWithPermission(permission); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture createAndLoadTrack(String name, CreationCause cause) { - phaser.register(); + this.phaser.register(); try { - return delegate.createAndLoadTrack(name, cause); + return this.delegate.createAndLoadTrack(name, cause); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture> loadTrack(String name) { - phaser.register(); + this.phaser.register(); try { - return delegate.loadTrack(name); + return this.delegate.loadTrack(name); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture loadAllTracks() { - phaser.register(); + this.phaser.register(); try { - return delegate.loadAllTracks(); + return this.delegate.loadAllTracks(); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture saveTrack(Track track) { - phaser.register(); + this.phaser.register(); try { - return delegate.saveTrack(track); + return this.delegate.saveTrack(track); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture deleteTrack(Track track, DeletionCause cause) { - phaser.register(); + this.phaser.register(); try { - return delegate.deleteTrack(track, cause); + return this.delegate.deleteTrack(track, cause); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture saveUUIDData(UUID uuid, String username) { - phaser.register(); + this.phaser.register(); try { - return delegate.saveUUIDData(uuid, username); + return this.delegate.saveUUIDData(uuid, username); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture getUUID(String username) { - phaser.register(); + this.phaser.register(); try { - return delegate.getUUID(username); + return this.delegate.getUUID(username); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } @Override public CompletableFuture getName(UUID uuid) { - phaser.register(); + this.phaser.register(); try { - return delegate.getName(uuid); + return this.delegate.getName(uuid); } finally { - phaser.arriveAndDeregister(); + this.phaser.arriveAndDeregister(); } } } diff --git a/common/src/main/java/me/lucko/luckperms/common/tasks/CacheHousekeepingTask.java b/common/src/main/java/me/lucko/luckperms/common/tasks/CacheHousekeepingTask.java index e5246aee0..bbcff252e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/tasks/CacheHousekeepingTask.java +++ b/common/src/main/java/me/lucko/luckperms/common/tasks/CacheHousekeepingTask.java @@ -25,22 +25,23 @@ package me.lucko.luckperms.common.tasks; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.model.User; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@RequiredArgsConstructor public class CacheHousekeepingTask implements Runnable { private final LuckPermsPlugin plugin; + public CacheHousekeepingTask(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + @Override public void run() { - for (User user : plugin.getUserManager().getAll().values()) { + for (User user : this.plugin.getUserManager().getAll().values()) { user.getCachedData().doCacheCleanup(); } - for (Group group : plugin.getGroupManager().getAll().values()) { + for (Group group : this.plugin.getGroupManager().getAll().values()) { group.getCachedData().doCacheCleanup(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/tasks/ExpireTemporaryTask.java b/common/src/main/java/me/lucko/luckperms/common/tasks/ExpireTemporaryTask.java index 7a8e455de..74d4300c1 100644 --- a/common/src/main/java/me/lucko/luckperms/common/tasks/ExpireTemporaryTask.java +++ b/common/src/main/java/me/lucko/luckperms/common/tasks/ExpireTemporaryTask.java @@ -25,29 +25,30 @@ package me.lucko.luckperms.common.tasks; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.common.model.Group; import me.lucko.luckperms.common.model.User; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; -@AllArgsConstructor public class ExpireTemporaryTask implements Runnable { private final LuckPermsPlugin plugin; + public ExpireTemporaryTask(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + @Override public void run() { boolean groupChanges = false; - for (Group group : plugin.getGroupManager().getAll().values()) { + for (Group group : this.plugin.getGroupManager().getAll().values()) { if (group.auditTemporaryPermissions()) { - plugin.getStorage().saveGroup(group); + this.plugin.getStorage().saveGroup(group); groupChanges = true; } } - for (User user : plugin.getUserManager().getAll().values()) { + for (User user : this.plugin.getUserManager().getAll().values()) { if (user.auditTemporaryPermissions()) { - plugin.getStorage().saveUser(user); + this.plugin.getStorage().saveUser(user); if (!groupChanges) { user.getRefreshBuffer().request(); } @@ -55,7 +56,7 @@ public class ExpireTemporaryTask implements Runnable { } if (groupChanges) { - plugin.getUpdateTaskBuffer().request(); + this.plugin.getUpdateTaskBuffer().request(); } } } \ No newline at end of file diff --git a/common/src/main/java/me/lucko/luckperms/common/tasks/UpdateTask.java b/common/src/main/java/me/lucko/luckperms/common/tasks/UpdateTask.java index 198d1d8ce..a3bf4ad65 100644 --- a/common/src/main/java/me/lucko/luckperms/common/tasks/UpdateTask.java +++ b/common/src/main/java/me/lucko/luckperms/common/tasks/UpdateTask.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.tasks; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.event.cause.CreationCause; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.plugin.LuckPermsPlugin; @@ -38,7 +36,6 @@ import java.util.concurrent.CompletableFuture; * *

Ensures that all local data is consistent with the storage.

*/ -@AllArgsConstructor public class UpdateTask implements Runnable { private final LuckPermsPlugin plugin; @@ -47,6 +44,11 @@ public class UpdateTask implements Runnable { */ private final boolean initialUpdate; + public UpdateTask(LuckPermsPlugin plugin, boolean initialUpdate) { + this.plugin = plugin; + this.initialUpdate = initialUpdate; + } + /** * Runs the update task * @@ -54,28 +56,28 @@ public class UpdateTask implements Runnable { */ @Override public void run() { - if (plugin.getEventFactory().handlePreSync(false)) { + if (this.plugin.getEventFactory().handlePreSync(false)) { return; } // Reload all groups - plugin.getStorage().loadAllGroups().join(); - String defaultGroup = plugin.getConfiguration().get(ConfigKeys.DEFAULT_GROUP_NAME); - if (!plugin.getGroupManager().isLoaded(defaultGroup)) { - plugin.getStorage().createAndLoadGroup(defaultGroup, CreationCause.INTERNAL).join(); + this.plugin.getStorage().loadAllGroups().join(); + String defaultGroup = this.plugin.getConfiguration().get(ConfigKeys.DEFAULT_GROUP_NAME); + if (!this.plugin.getGroupManager().isLoaded(defaultGroup)) { + this.plugin.getStorage().createAndLoadGroup(defaultGroup, CreationCause.INTERNAL).join(); } // Reload all tracks - plugin.getStorage().loadAllTracks().join(); + this.plugin.getStorage().loadAllTracks().join(); // Refresh all online users. - CompletableFuture userUpdateFut = plugin.getUserManager().updateAllUsers(); - if (!initialUpdate) { + CompletableFuture userUpdateFut = this.plugin.getUserManager().updateAllUsers(); + if (!this.initialUpdate) { userUpdateFut.join(); } - plugin.onPostUpdate(); + this.plugin.onPostUpdate(); - plugin.getEventFactory().handlePostSync(); + this.plugin.getEventFactory().handlePostSync(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/treeview/ImmutableTreeNode.java b/common/src/main/java/me/lucko/luckperms/common/treeview/ImmutableTreeNode.java index 8216a4b33..e5aad8ff0 100644 --- a/common/src/main/java/me/lucko/luckperms/common/treeview/ImmutableTreeNode.java +++ b/common/src/main/java/me/lucko/luckperms/common/treeview/ImmutableTreeNode.java @@ -37,6 +37,8 @@ import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; +import javax.annotation.Nonnull; + /** * An immutable and sorted version of TreeNode * @@ -66,7 +68,7 @@ public class ImmutableTreeNode implements Comparable { } public Optional> getChildren() { - return Optional.ofNullable(children); + return Optional.ofNullable(this.children); } /** @@ -77,12 +79,12 @@ public class ImmutableTreeNode implements Comparable { * @return the node endings */ public List> getNodeEndings() { - if (children == null) { + if (this.children == null) { return Collections.emptyList(); } List> results = new ArrayList<>(); - for (Map.Entry node : children.entrySet()) { + for (Map.Entry node : this.children.entrySet()) { // add self results.add(Maps.immutableEntry(0, node.getKey())); @@ -100,7 +102,7 @@ public class ImmutableTreeNode implements Comparable { } @Override - public int compareTo(ImmutableTreeNode o) { - return (children != null) == o.getChildren().isPresent() ? 0 : (children != null ? 1 : -1); + public int compareTo(@Nonnull ImmutableTreeNode o) { + return (this.children != null) == o.getChildren().isPresent() ? 0 : (this.children != null ? 1 : -1); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/treeview/PermissionVault.java b/common/src/main/java/me/lucko/luckperms/common/treeview/PermissionVault.java index fced2fd0d..14a13b829 100644 --- a/common/src/main/java/me/lucko/luckperms/common/treeview/PermissionVault.java +++ b/common/src/main/java/me/lucko/luckperms/common/treeview/PermissionVault.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.treeview; -import lombok.Getter; -import lombok.NonNull; - import com.google.common.base.Splitter; import com.google.common.collect.ImmutableSet; @@ -47,7 +44,6 @@ public class PermissionVault implements Runnable { private static final Splitter DOT_SPLIT = Splitter.on('.').omitEmptyStrings(); // the root node in the tree - @Getter private final TreeNode rootNode; // the known permissions already in the vault @@ -60,21 +56,25 @@ public class PermissionVault implements Runnable { private boolean shutdown = false; public PermissionVault(Executor executor) { - rootNode = new TreeNode(); - knownPermissions = ConcurrentHashMap.newKeySet(3000); - queue = new ConcurrentLinkedQueue<>(); + this.rootNode = new TreeNode(); + this.knownPermissions = ConcurrentHashMap.newKeySet(3000); + this.queue = new ConcurrentLinkedQueue<>(); executor.execute(this); } + public TreeNode getRootNode() { + return this.rootNode; + } + @Override public void run() { while (true) { - for (String e; (e = queue.poll()) != null; ) { + for (String e; (e = this.queue.poll()) != null; ) { try { String s = e.toLowerCase(); // only attempt an insert if we're not seen this permission before - if (knownPermissions.add(s)) { + if (this.knownPermissions.add(s)) { insert(s); } } catch (Exception ex) { @@ -82,7 +82,7 @@ public class PermissionVault implements Runnable { } } - if (shutdown) { + if (this.shutdown) { return; } @@ -92,20 +92,23 @@ public class PermissionVault implements Runnable { } } - public void offer(@NonNull String permission) { - queue.offer(permission); + public void offer(String permission) { + if (permission == null) { + throw new NullPointerException("permission"); + } + this.queue.offer(permission); } public Set getKnownPermissions() { - return ImmutableSet.copyOf(knownPermissions); + return ImmutableSet.copyOf(this.knownPermissions); } public List rootAsList() { - return rootNode.makeImmutableCopy().getNodeEndings().stream().map(Map.Entry::getValue).collect(Collectors.toList()); + return this.rootNode.makeImmutableCopy().getNodeEndings().stream().map(Map.Entry::getValue).collect(Collectors.toList()); } public int getSize() { - return rootNode.getDeepSize(); + return this.rootNode.getDeepSize(); } private void insert(String permission) { @@ -113,14 +116,14 @@ public class PermissionVault implements Runnable { List parts = DOT_SPLIT.splitToList(permission); // insert the permission into the node structure - TreeNode current = rootNode; + TreeNode current = this.rootNode; for (String part : parts) { current = current.getChildMap().computeIfAbsent(part, s -> new TreeNode()); } } public void shutdown() { - shutdown = true; + this.shutdown = true; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/treeview/TreeNode.java b/common/src/main/java/me/lucko/luckperms/common/treeview/TreeNode.java index 12654db40..2b7430687 100644 --- a/common/src/main/java/me/lucko/luckperms/common/treeview/TreeNode.java +++ b/common/src/main/java/me/lucko/luckperms/common/treeview/TreeNode.java @@ -39,29 +39,29 @@ public class TreeNode { // lazy init public synchronized Map getChildMap() { - if (children == null) { - children = new ConcurrentHashMap<>(); + if (this.children == null) { + this.children = new ConcurrentHashMap<>(); } - return children; + return this.children; } public Optional> getChildren() { - return Optional.ofNullable(children); + return Optional.ofNullable(this.children); } public int getDeepSize() { - if (children == null) { + if (this.children == null) { return 1; } else { - return children.values().stream().mapToInt(TreeNode::getDeepSize).sum(); + return this.children.values().stream().mapToInt(TreeNode::getDeepSize).sum(); } } public ImmutableTreeNode makeImmutableCopy() { - if (children == null) { + if (this.children == null) { return new ImmutableTreeNode(null); } else { - return new ImmutableTreeNode(children.entrySet().stream() + return new ImmutableTreeNode(this.children.entrySet().stream() .map(e -> Maps.immutableEntry( e.getKey(), e.getValue().makeImmutableCopy() diff --git a/common/src/main/java/me/lucko/luckperms/common/treeview/TreeView.java b/common/src/main/java/me/lucko/luckperms/common/treeview/TreeView.java index ad629f39b..a1a1cfb99 100644 --- a/common/src/main/java/me/lucko/luckperms/common/treeview/TreeView.java +++ b/common/src/main/java/me/lucko/luckperms/common/treeview/TreeView.java @@ -72,7 +72,7 @@ public class TreeView { * @return true if the treeview has data */ public boolean hasData() { - return view != null; + return this.view != null; } /** @@ -125,15 +125,15 @@ public class TreeView { private List> asTreeList() { // work out the prefix to apply // since the view is relative, we need to prepend this to all permissions - String prefix = rootPosition.equals(".") ? "" : (rootPosition + "."); + String prefix = this.rootPosition.equals(".") ? "" : (this.rootPosition + "."); List> ret = new ArrayList<>(); // iterate the node endings in the view - for (Map.Entry s : view.getNodeEndings()) { + for (Map.Entry s : this.view.getNodeEndings()) { // don't include the node if it exceeds the max level - if (s.getKey() >= maxLevel) { + if (s.getKey() >= this.maxLevel) { continue; } @@ -241,7 +241,7 @@ public class TreeView { private ImmutableList.Builder getPasteHeader(String version, String referenceUser, int size) { String date = DATE_FORMAT.format(new Date(System.currentTimeMillis())); - String selection = rootPosition.equals(".") ? "any" : "`" + rootPosition + "`"; + String selection = this.rootPosition.equals(".") ? "any" : "`" + this.rootPosition + "`"; return ImmutableList.builder() .add("## Permission Tree") @@ -250,7 +250,7 @@ public class TreeView { .add("### Metadata") .add("| Selection | Max Recursion | Reference User | Size | Produced at |") .add("|-----------|---------------|----------------|------|-------------|") - .add("| " + selection + " | " + maxLevel + " | " + referenceUser + " | **" + size + "** | " + date + " |") + .add("| " + selection + " | " + this.maxLevel + " | " + referenceUser + " | **" + size + "** | " + date + " |") .add("") .add("### Output"); } diff --git a/common/src/main/java/me/lucko/luckperms/common/treeview/TreeViewBuilder.java b/common/src/main/java/me/lucko/luckperms/common/treeview/TreeViewBuilder.java index 0f69bc475..d42bb5ebc 100644 --- a/common/src/main/java/me/lucko/luckperms/common/treeview/TreeViewBuilder.java +++ b/common/src/main/java/me/lucko/luckperms/common/treeview/TreeViewBuilder.java @@ -25,21 +25,15 @@ package me.lucko.luckperms.common.treeview; -import lombok.Setter; -import lombok.experimental.Accessors; - /** * Builds a {@link TreeView}. */ -@Accessors(fluent = true) public class TreeViewBuilder { public static TreeViewBuilder newBuilder() { return new TreeViewBuilder(); } - @Setter private String rootPosition; - @Setter private int maxLevels; private TreeViewBuilder() { @@ -47,17 +41,27 @@ public class TreeViewBuilder { this.maxLevels = 5; } + public TreeViewBuilder rootPosition(String rootPosition) { + this.rootPosition = rootPosition; + return this; + } + + public TreeViewBuilder maxLevels(int maxLevels) { + this.maxLevels = maxLevels; + return this; + } + public TreeView build(PermissionVault source) { - if (maxLevels < 1) { - maxLevels = 1; + if (this.maxLevels < 1) { + this.maxLevels = 1; } - if (rootPosition.equals("") || rootPosition.equals("*")) { - rootPosition = "."; - } else if (!rootPosition.equals(".") && rootPosition.endsWith(".")) { - rootPosition = rootPosition.substring(0, rootPosition.length() - 1); + if (this.rootPosition.equals("") || this.rootPosition.equals("*")) { + this.rootPosition = "."; + } else if (!this.rootPosition.equals(".") && this.rootPosition.endsWith(".")) { + this.rootPosition = this.rootPosition.substring(0, this.rootPosition.length() - 1); } - return new TreeView(source, rootPosition, maxLevels); + return new TreeView(source, this.rootPosition, this.maxLevels); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/Cycle.java b/common/src/main/java/me/lucko/luckperms/common/utils/Cycle.java index 09cae7da4..5974f0931 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/Cycle.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/Cycle.java @@ -46,34 +46,34 @@ public class Cycle { } public int getIndex() { - return index; + return this.index; } public E current() { synchronized (this) { - return objects.get(index); + return this.objects.get(this.index); } } public E next() { synchronized (this) { - index++; - index = index > objects.size() - 1 ? 0 : index; + this.index++; + this.index = this.index > this.objects.size() - 1 ? 0 : this.index; - return objects.get(index); + return this.objects.get(this.index); } } public E back() { synchronized (this) { - index--; - index = index == -1 ? objects.size() - 1 : index; + this.index--; + this.index = this.index == -1 ? this.objects.size() - 1 : this.index; - return objects.get(index); + return this.objects.get(this.index); } } public List getBacking() { - return objects; + return this.objects; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/DateUtil.java b/common/src/main/java/me/lucko/luckperms/common/utils/DateUtil.java index 57faa573f..f4a0891e5 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/DateUtil.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/DateUtil.java @@ -31,8 +31,6 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import java.util.Calendar; import java.util.GregorianCalendar; import java.util.regex.Matcher; @@ -41,8 +39,7 @@ import java.util.regex.Pattern; /** * Translates unix timestamps / durations into a readable format */ -@UtilityClass -public class DateUtil { +public final class DateUtil { private static final Pattern TIME_PATTERN = Pattern.compile("(?:([0-9]+)\\s*y[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*mo[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*w[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*d[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*h[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*m[a-z]*[,\\s]*)?" + "(?:([0-9]+)\\s*(?:s[a-z]*)?)?", Pattern.CASE_INSENSITIVE); private static final int MAX_YEARS = 100000; @@ -259,4 +256,7 @@ public class DateUtil { public static class IllegalDateException extends Exception { } + + private DateUtil() {} + } \ No newline at end of file diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/HikariSupplier.java b/common/src/main/java/me/lucko/luckperms/common/utils/HikariSupplier.java index ef5e95790..ae2c96994 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/HikariSupplier.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/HikariSupplier.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.RequiredArgsConstructor; - import com.zaxxer.hikari.HikariDataSource; import java.sql.Connection; @@ -35,7 +33,6 @@ import java.sql.SQLException; /** * A simple hikari wrapper */ -@RequiredArgsConstructor public class HikariSupplier implements AutoCloseable { private final String address; @@ -45,24 +42,31 @@ public class HikariSupplier implements AutoCloseable { private HikariDataSource hikari; + public HikariSupplier(String address, String database, String username, String password) { + this.address = address; + this.database = database; + this.username = username; + this.password = password; + } + public void setup(String poolName) { - hikari = new HikariDataSource(); - hikari.setPoolName(poolName); - hikari.setMaximumPoolSize(2); - hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource"); - hikari.addDataSourceProperty("serverName", address.split(":")[0]); - hikari.addDataSourceProperty("port", address.split(":")[1]); - hikari.addDataSourceProperty("databaseName", database); - hikari.addDataSourceProperty("user", username); - hikari.addDataSourceProperty("password", password); + this.hikari = new HikariDataSource(); + this.hikari.setPoolName(poolName); + this.hikari.setMaximumPoolSize(2); + this.hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource"); + this.hikari.addDataSourceProperty("serverName", this.address.split(":")[0]); + this.hikari.addDataSourceProperty("port", this.address.split(":")[1]); + this.hikari.addDataSourceProperty("databaseName", this.database); + this.hikari.addDataSourceProperty("user", this.username); + this.hikari.addDataSourceProperty("password", this.password); } @Override public void close() { - hikari.close(); + this.hikari.close(); } public Connection getConnection() throws SQLException { - return hikari.getConnection(); + return this.hikari.getConnection(); } } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/ImmutableCollectors.java b/common/src/main/java/me/lucko/luckperms/common/utils/ImmutableCollectors.java index d7406b505..42e197667 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/ImmutableCollectors.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/ImmutableCollectors.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -36,8 +34,7 @@ import java.util.EnumSet; import java.util.function.Function; import java.util.stream.Collector; -@UtilityClass -public class ImmutableCollectors { +public final class ImmutableCollectors { private static final Collector, ImmutableList> LIST = Collector.of( ImmutableList.Builder::new, @@ -91,4 +88,6 @@ public class ImmutableCollectors { ); } + private ImmutableCollectors() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/LoginHelper.java b/common/src/main/java/me/lucko/luckperms/common/utils/LoginHelper.java index 30f93981d..de75dc479 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/LoginHelper.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/LoginHelper.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.common.assignments.AssignmentRule; import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.model.User; @@ -38,10 +36,9 @@ import java.util.concurrent.CompletableFuture; /** * Utilities for use in platform listeners */ -@UtilityClass -public class LoginHelper { +public final class LoginHelper { - public static User loadUser(LuckPermsPlugin plugin, UUID u, String username, boolean joinUuidSave) throws Exception { + public static User loadUser(LuckPermsPlugin plugin, UUID u, String username, boolean joinUuidSave) { final long startTime = System.currentTimeMillis(); final UuidCache cache = plugin.getUuidCache(); @@ -100,4 +97,6 @@ public class LoginHelper { return user; } + private LoginHelper() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/PatternCache.java b/common/src/main/java/me/lucko/luckperms/common/utils/PatternCache.java index 264c4138d..899543db2 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/PatternCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/PatternCache.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.AllArgsConstructor; -import lombok.experimental.UtilityClass; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.collect.Maps; @@ -36,8 +33,7 @@ import java.util.Map; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; -@UtilityClass -public class PatternCache { +public final class PatternCache { private static final NullablePattern NULL_PATTERN = new NullablePattern(null); @@ -67,9 +63,14 @@ public class PatternCache { return compile(buildDelimitedMatcher(delim, esc)); } - @AllArgsConstructor private static final class NullablePattern { private final Pattern pattern; + + public NullablePattern(Pattern pattern) { + this.pattern = pattern; + } } + private PatternCache() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/Predicates.java b/common/src/main/java/me/lucko/luckperms/common/utils/Predicates.java index 42f17af83..bf975fd2b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/Predicates.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/Predicates.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import java.util.Set; import java.util.function.Predicate; import java.util.stream.Collectors; @@ -35,8 +33,7 @@ import java.util.stream.IntStream; /** * A collection of predicate utilities used mostly in command classes */ -@UtilityClass -public class Predicates { +public final class Predicates { private static final Predicate FALSE = o -> false; private static final Predicate TRUE = o -> true; @@ -84,4 +81,6 @@ public class Predicates { public static Predicate inverse(Predicate t) { return t2 -> !t.test(t2); } + + private Predicates() {} } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/SafeIterator.java b/common/src/main/java/me/lucko/luckperms/common/utils/SafeIterator.java index 5c4f15aec..2a4c8818c 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/SafeIterator.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/SafeIterator.java @@ -25,13 +25,10 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import java.util.function.Consumer; import java.util.function.Function; -@UtilityClass -public class SafeIterator { +public final class SafeIterator { public static void iterate(Iterable iterable, Consumer action) { for (I i : iterable) { @@ -73,4 +70,6 @@ public class SafeIterator { } } + private SafeIterator() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/Scripting.java b/common/src/main/java/me/lucko/luckperms/common/utils/Scripting.java index a7bdd9654..dddfbb52e 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/Scripting.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/Scripting.java @@ -25,16 +25,13 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import javax.script.ScriptEngine; import javax.script.ScriptEngineManager; /** * Nashorn provider utility */ -@UtilityClass -public class Scripting { +public final class Scripting { private static ScriptEngine SCRIPT_ENGINE = null; // Lazily load @@ -45,4 +42,6 @@ public class Scripting { return SCRIPT_ENGINE; } + private Scripting() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/TextUtils.java b/common/src/main/java/me/lucko/luckperms/common/utils/TextUtils.java index 1ddff0bef..22f2989b3 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/TextUtils.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/TextUtils.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.experimental.UtilityClass; - import net.kyori.text.Component; import net.kyori.text.TextComponent; import net.kyori.text.serializer.ComponentSerializers; @@ -36,30 +34,29 @@ import java.util.stream.Collectors; import java.util.stream.Stream; @SuppressWarnings("deprecation") -@UtilityClass -public class TextUtils { +public final class TextUtils { - public String joinNewline(String... strings) { + public static String joinNewline(String... strings) { return joinNewline(Arrays.stream(strings)); } - public String joinNewline(Stream strings) { + public static String joinNewline(Stream strings) { return strings.collect(Collectors.joining("\n")); } - public TextComponent fromLegacy(String input, char character) { + public static TextComponent fromLegacy(String input, char character) { return ComponentSerializers.LEGACY.deserialize(input, character); } - public TextComponent fromLegacy(String input) { + public static TextComponent fromLegacy(String input) { return ComponentSerializers.LEGACY.deserialize(input); } - public String toLegacy(Component component, char character) { + public static String toLegacy(Component component, char character) { return ComponentSerializers.LEGACY.serialize(component, character); } - public String toLegacy(Component component) { + public static String toLegacy(Component component) { return ComponentSerializers.LEGACY.serialize(component); } @@ -71,4 +68,6 @@ public class TextUtils { return input; } + private TextUtils() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/utils/UuidCache.java b/common/src/main/java/me/lucko/luckperms/common/utils/UuidCache.java index c34f00273..3f02ed350 100644 --- a/common/src/main/java/me/lucko/luckperms/common/utils/UuidCache.java +++ b/common/src/main/java/me/lucko/luckperms/common/utils/UuidCache.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.utils; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.BiMap; import com.google.common.collect.HashBiMap; import com.google.common.collect.Maps; @@ -41,40 +38,45 @@ import java.util.UUID; /** * @see me.lucko.luckperms.api.UuidCache for docs */ -@RequiredArgsConstructor public class UuidCache { private final LuckPermsPlugin plugin; // External UUID --> Internal UUID private final BiMap cache = Maps.synchronizedBiMap(HashBiMap.create()); - @Getter private final ApiUuidCache delegate = new ApiUuidCache(this); + public UuidCache(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + public UUID getUUID(UUID external) { - return inUse() ? external : cache.getOrDefault(external, external); + return inUse() ? external : this.cache.getOrDefault(external, external); } public UUID getExternalUUID(UUID internal) { - return inUse() ? internal : cache.inverse().getOrDefault(internal, internal); + return inUse() ? internal : this.cache.inverse().getOrDefault(internal, internal); } public void addToCache(UUID external, UUID internal) { if (inUse()) return; - cache.forcePut(external, internal); + this.cache.forcePut(external, internal); } public void clearCache(UUID external) { if (inUse()) return; - cache.remove(external); + this.cache.remove(external); } public int getSize() { - return inUse() ? 0 : cache.size(); + return inUse() ? 0 : this.cache.size(); } private boolean inUse() { - return plugin.getConfiguration().get(ConfigKeys.USE_SERVER_UUIDS); + return this.plugin.getConfiguration().get(ConfigKeys.USE_SERVER_UUIDS); } + public ApiUuidCache getDelegate() { + return this.delegate; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/verbose/CheckData.java b/common/src/main/java/me/lucko/luckperms/common/verbose/CheckData.java index e394ad78c..093a31e9b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/verbose/CheckData.java +++ b/common/src/main/java/me/lucko/luckperms/common/verbose/CheckData.java @@ -25,17 +25,12 @@ package me.lucko.luckperms.common.verbose; -import lombok.AllArgsConstructor; -import lombok.Getter; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ImmutableContextSet; /** * Holds the data from a permission check */ -@Getter -@AllArgsConstructor public class CheckData { /** @@ -68,4 +63,36 @@ public class CheckData { */ private final Tristate result; + public CheckData(CheckOrigin checkOrigin, String checkTarget, ImmutableContextSet checkContext, StackTraceElement[] checkTrace, String permission, Tristate result) { + this.checkOrigin = checkOrigin; + this.checkTarget = checkTarget; + this.checkContext = checkContext; + this.checkTrace = checkTrace; + this.permission = permission; + this.result = result; + } + + public CheckOrigin getCheckOrigin() { + return this.checkOrigin; + } + + public String getCheckTarget() { + return this.checkTarget; + } + + public ImmutableContextSet getCheckContext() { + return this.checkContext; + } + + public StackTraceElement[] getCheckTrace() { + return this.checkTrace; + } + + public String getPermission() { + return this.permission; + } + + public Tristate getResult() { + return this.result; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/verbose/CheckOrigin.java b/common/src/main/java/me/lucko/luckperms/common/verbose/CheckOrigin.java index 6108fdfa0..5e423335f 100644 --- a/common/src/main/java/me/lucko/luckperms/common/verbose/CheckOrigin.java +++ b/common/src/main/java/me/lucko/luckperms/common/verbose/CheckOrigin.java @@ -25,14 +25,9 @@ package me.lucko.luckperms.common.verbose; -import lombok.AllArgsConstructor; -import lombok.Getter; - /** * Represents the origin of a permission check */ -@Getter -@AllArgsConstructor public enum CheckOrigin { /** @@ -57,4 +52,11 @@ public enum CheckOrigin { private final char code; + CheckOrigin(char code) { + this.code = code; + } + + public char getCode() { + return this.code; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseFilter.java b/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseFilter.java index 11f912af1..837e5c659 100644 --- a/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseFilter.java +++ b/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseFilter.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.verbose; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.common.utils.Scripting; import java.util.StringTokenizer; @@ -36,8 +34,7 @@ import javax.script.ScriptEngine; /** * Tests verbose filters */ -@UtilityClass -public class VerboseFilter { +public final class VerboseFilter { /** * Evaluates whether the passed check data passes the filter @@ -163,4 +160,6 @@ public class VerboseFilter { token.equals("!"); } + private VerboseFilter() {} + } diff --git a/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseHandler.java b/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseHandler.java index a5ed8114b..3f661d196 100644 --- a/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseHandler.java +++ b/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseHandler.java @@ -56,8 +56,8 @@ public class VerboseHandler implements Runnable { public VerboseHandler(Executor executor, String pluginVersion) { this.pluginVersion = "v" + pluginVersion; - listeners = new ConcurrentHashMap<>(); - queue = new ConcurrentLinkedQueue<>(); + this.listeners = new ConcurrentHashMap<>(); + this.queue = new ConcurrentLinkedQueue<>(); executor.execute(this); } @@ -76,7 +76,7 @@ public class VerboseHandler implements Runnable { */ public void offerCheckData(CheckOrigin checkOrigin, String checkTarget, ContextSet checkContext, String permission, Tristate result) { // don't bother even processing the check if there are no listeners registered - if (!listening) { + if (!this.listening) { return; } @@ -84,7 +84,7 @@ public class VerboseHandler implements Runnable { StackTraceElement[] trace = new Exception().getStackTrace(); // add the check data to a queue to be processed later. - queue.offer(new CheckData(checkOrigin, checkTarget, checkContext.makeImmutable(), trace, permission, result)); + this.queue.offer(new CheckData(checkOrigin, checkTarget, checkContext.makeImmutable(), trace, permission, result)); } /** @@ -95,8 +95,8 @@ public class VerboseHandler implements Runnable { * @param notify if the sender should be notified in chat on each check */ public void registerListener(Sender sender, String filter, boolean notify) { - listeners.put(sender.getUuid(), new VerboseListener(pluginVersion, sender, filter, notify)); - listening = true; + this.listeners.put(sender.getUuid(), new VerboseListener(this.pluginVersion, sender, filter, notify)); + this.listening = true; } /** @@ -109,7 +109,7 @@ public class VerboseHandler implements Runnable { // immediately flush, so the listener gets all current data flush(); - return listeners.remove(uuid); + return this.listeners.remove(uuid); } @Override @@ -117,18 +117,18 @@ public class VerboseHandler implements Runnable { while (true) { // remove listeners where the sender is no longer valid - listeners.values().removeIf(l -> !l.getNotifiedSender().isValid()); + this.listeners.values().removeIf(l -> !l.getNotifiedSender().isValid()); // handle all checks in the queue flush(); // break the loop if the handler has been shutdown - if (shutdown) { + if (this.shutdown) { return; } // update listening state - listening = !listeners.isEmpty(); + this.listening = !this.listeners.isEmpty(); try { Thread.sleep(100); @@ -140,14 +140,14 @@ public class VerboseHandler implements Runnable { * Flushes the current check data to the listeners. */ public synchronized void flush() { - for (CheckData e; (e = queue.poll()) != null; ) { - for (VerboseListener listener : listeners.values()) { + for (CheckData e; (e = this.queue.poll()) != null; ) { + for (VerboseListener listener : this.listeners.values()) { listener.acceptData(e); } } } public void shutdown() { - shutdown = true; + this.shutdown = true; } } diff --git a/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseListener.java b/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseListener.java index e35c9d1bd..d4c7e2c9b 100644 --- a/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseListener.java +++ b/common/src/main/java/me/lucko/luckperms/common/verbose/VerboseListener.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.common.verbose; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.ImmutableList; import com.google.common.collect.Maps; @@ -55,7 +52,6 @@ import java.util.stream.Collectors; /** * Accepts and processes {@link CheckData}, passed from the {@link VerboseHandler}. */ -@RequiredArgsConstructor public class VerboseListener { private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z"); @@ -72,7 +68,6 @@ public class VerboseListener { private final String pluginVersion; // the sender to notify each time the listener processes a check which passes the filter - @Getter private final Sender notifiedSender; // the filter string @@ -91,6 +86,13 @@ public class VerboseListener { // the checks which passed the filter, up to a max size of #DATA_TRUNCATION private final List results = new ArrayList<>(DATA_TRUNCATION / 10); + public VerboseListener(String pluginVersion, Sender notifiedSender, String filter, boolean notify) { + this.pluginVersion = pluginVersion; + this.notifiedSender = notifiedSender; + this.filter = filter; + this.notify = notify; + } + /** * Accepts and processes check data. * @@ -98,26 +100,26 @@ public class VerboseListener { */ public void acceptData(CheckData data) { // increment handled counter - counter.incrementAndGet(); + this.counter.incrementAndGet(); // check if the data passes our filters - if (!VerboseFilter.passesFilter(data, filter)) { + if (!VerboseFilter.passesFilter(data, this.filter)) { return; } // increment the matched filter - matchedCounter.incrementAndGet(); + this.matchedCounter.incrementAndGet(); // record the check, if we have space for it - if (results.size() < DATA_TRUNCATION) { - results.add(data); + if (this.results.size() < DATA_TRUNCATION) { + this.results.add(data); } // handle notifications - if (notify) { + if (this.notify) { StringBuilder msgContent = new StringBuilder(); - if (notifiedSender.isConsole()) { + if (this.notifiedSender.isConsole()) { msgContent.append("&8[&2") .append(data.getCheckOrigin().getCode()) .append("&8] "); @@ -131,13 +133,13 @@ public class VerboseListener { .append(getTristateColor(data.getResult())) .append(data.getResult().name().toLowerCase()); - if (notifiedSender.isConsole()) { + if (this.notifiedSender.isConsole()) { // just send as a raw message - Message.VERBOSE_LOG.send(notifiedSender, msgContent.toString()); + Message.VERBOSE_LOG.send(this.notifiedSender, msgContent.toString()); } else { // form a hoverevent from the check trace - TextComponent textComponent = TextUtils.fromLegacy(Message.VERBOSE_LOG.asString(notifiedSender.getPlatform().getLocaleManager(), msgContent.toString())); + TextComponent textComponent = TextUtils.fromLegacy(Message.VERBOSE_LOG.asString(this.notifiedSender.getPlatform().getLocaleManager(), msgContent.toString())); // build the text List hover = new ArrayList<>(); @@ -153,7 +155,7 @@ public class VerboseListener { // send the message HoverEvent e = new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextUtils.fromLegacy(TextUtils.joinNewline(hover.stream()), CommandManager.AMPERSAND_CHAR)); TextComponent msg = textComponent.toBuilder().applyDeep(comp -> comp.hoverEvent(e)).build(); - notifiedSender.sendMessage(msg); + this.notifiedSender.sendMessage(msg); } } } @@ -170,9 +172,9 @@ public class VerboseListener { // retrieve variables long now = System.currentTimeMillis(); - String startDate = DATE_FORMAT.format(new Date(startTime)); + String startDate = DATE_FORMAT.format(new Date(this.startTime)); String endDate = DATE_FORMAT.format(new Date(now)); - long secondsTaken = (now - startTime) / 1000L; + long secondsTaken = (now - this.startTime) / 1000L; String duration = DateUtil.formatTimeShort(secondsTaken); String filter = this.filter; @@ -185,7 +187,7 @@ public class VerboseListener { // start building the message output ImmutableList.Builder prettyOutput = ImmutableList.builder() .add("## Verbose Checking Output") - .add("#### This file was automatically generated by [LuckPerms](https://github.com/lucko/LuckPerms) " + pluginVersion) + .add("#### This file was automatically generated by [LuckPerms](https://github.com/lucko/LuckPerms) " + this.pluginVersion) .add("") .add("### Metadata") .add("| Key | Value |") @@ -193,20 +195,20 @@ public class VerboseListener { .add("| Start Time | " + startDate + " |") .add("| End Time | " + endDate + " |") .add("| Duration | " + duration +" |") - .add("| Count | **" + matchedCounter.get() + "** / " + counter.get() + " |") - .add("| User | " + notifiedSender.getNameWithLocation() + " |") + .add("| Count | **" + this.matchedCounter.get() + "** / " + this.counter.get() + " |") + .add("| User | " + this.notifiedSender.getNameWithLocation() + " |") .add("| Filter | " + filter + " |") .add("| Include traces | " + showTraces + " |") .add(""); // warn if data was truncated - if (matchedCounter.get() > results.size()) { + if (this.matchedCounter.get() > this.results.size()) { prettyOutput.add("**WARN:** Result set exceeded max size of " + DATA_TRUNCATION + ". The output below was truncated to " + DATA_TRUNCATION + " entries."); prettyOutput.add(""); } // explain why some traces may be missing - if (showTraces && results.size() > TRACE_DATA_TRUNCATION) { + if (showTraces && this.results.size() > TRACE_DATA_TRUNCATION) { prettyOutput.add("**WARN:** Result set exceeded size of " + TRACE_DATA_TRUNCATION + ". The traced output below was truncated to " + TRACE_DATA_TRUNCATION + " entries. "); prettyOutput.add("Either refine the query using a more specific filter, or disable tracing by adding '--slim' to the end of the paste command."); prettyOutput.add(""); @@ -226,7 +228,7 @@ public class VerboseListener { // how many instances have been printed so far AtomicInteger printedCount = new AtomicInteger(0); - for (CheckData c : results) { + for (CheckData c : this.results) { if (!showTraces) { // if traces aren't being shown, just append using raw markdown @@ -261,7 +263,7 @@ public class VerboseListener { csvOutput.add(escapeCommas(c.getCheckTarget()) + "," + escapeCommas(c.getPermission()) + "," + c.getResult().name().toLowerCase()); } } - results.clear(); + this.results.clear(); ImmutableList.Builder> content = ImmutableList.builder(); content.add(Maps.immutableEntry("luckperms-verbose.md", prettyOutput.build().stream().collect(Collectors.joining("\n")))); @@ -344,4 +346,7 @@ public class VerboseListener { } } + public Sender getNotifiedSender() { + return this.notifiedSender; + } } diff --git a/common/src/main/java/me/lucko/luckperms/common/webeditor/WebEditorUtils.java b/common/src/main/java/me/lucko/luckperms/common/webeditor/WebEditorUtils.java index d1dfa6608..0c2264f16 100644 --- a/common/src/main/java/me/lucko/luckperms/common/webeditor/WebEditorUtils.java +++ b/common/src/main/java/me/lucko/luckperms/common/webeditor/WebEditorUtils.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.common.webeditor; -import lombok.experimental.UtilityClass; - import com.google.gson.Gson; import com.google.gson.JsonArray; import com.google.gson.JsonElement; @@ -60,8 +58,7 @@ import java.util.stream.Stream; /** * Utility methods for interacting with the LuckPerms web permission editor. */ -@UtilityClass -public class WebEditorUtils { +public final class WebEditorUtils { private static final String FILE_NAME = "luckperms-data.json"; private static final String GIST_API_URL = "https://api.github.com/gists"; @@ -274,4 +271,6 @@ public class WebEditorUtils { return nodes; } + private WebEditorUtils() {} + } diff --git a/pom.xml b/pom.xml index dd35d8f38..d923db069 100644 --- a/pom.xml +++ b/pom.xml @@ -65,7 +65,6 @@ 3.7.0 3.1.0 - 1.16.18 diff --git a/sponge/pom.xml b/sponge/pom.xml index 1985b397f..184ba2cff 100644 --- a/sponge/pom.xml +++ b/sponge/pom.xml @@ -113,13 +113,6 @@ ${project.version} compile - - - org.projectlombok - lombok - ${lombok.version} - provided - diff --git a/sponge/sponge-service-api6/pom.xml b/sponge/sponge-service-api6/pom.xml index 958681169..9d1b58ee4 100644 --- a/sponge/sponge-service-api6/pom.xml +++ b/sponge/sponge-service-api6/pom.xml @@ -57,13 +57,6 @@ 6.0.0 provided - - - org.projectlombok - lombok - ${lombok.version} - provided - diff --git a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionDescriptionProxy.java b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionDescriptionProxy.java index 874b3f4c7..4aeb2d666 100644 --- a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionDescriptionProxy.java +++ b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionDescriptionProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api6; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -39,43 +37,53 @@ import org.spongepowered.api.text.Text; import java.util.Map; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public final class PermissionDescriptionProxy implements PermissionDescription { private final LPPermissionService service; private final LPPermissionDescription handle; + public PermissionDescriptionProxy(LPPermissionService service, LPPermissionDescription handle) { + this.service = service; + this.handle = handle; + } + + @Nonnull @Override public String getId() { - return handle.getId(); + return this.handle.getId(); } + @Nonnull @Override public Text getDescription() { - return handle.getDescription().orElse(Text.EMPTY); + return this.handle.getDescription().orElse(Text.EMPTY); } + @Nonnull @Override public PluginContainer getOwner() { - return handle.getOwner().orElseGet(() -> Sponge.getGame().getPluginManager().fromInstance(service.getPlugin()).orElseThrow(() -> new RuntimeException("Unable to get LuckPerms instance."))); + return this.handle.getOwner().orElseGet(() -> Sponge.getGame().getPluginManager().fromInstance(this.service.getPlugin()).orElseThrow(() -> new RuntimeException("Unable to get LuckPerms instance."))); } + @Nonnull @Override - public Map getAssignedSubjects(String s) { - return handle.getAssignedSubjects(s).entrySet().stream() + public Map getAssignedSubjects(@Nonnull String s) { + return this.handle.getAssignedSubjects(s).entrySet().stream() .collect(ImmutableCollectors.toMap( - e -> new SubjectProxy(service, e.getKey().toReference()), + e -> new SubjectProxy(this.service, e.getKey().toReference()), Map.Entry::getValue )); } @Override public boolean equals(Object o) { - return o == this || o instanceof PermissionDescriptionProxy && handle.equals(((PermissionDescriptionProxy) o).handle); + return o == this || o instanceof PermissionDescriptionProxy && this.handle.equals(((PermissionDescriptionProxy) o).handle); } @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } @Override diff --git a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionServiceProxy.java b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionServiceProxy.java index 86088266b..764d262dd 100644 --- a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionServiceProxy.java +++ b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/PermissionServiceProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api6; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -43,33 +41,43 @@ import java.util.Collection; import java.util.Map; import java.util.Optional; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public final class PermissionServiceProxy implements PermissionService { private final LPPermissionService handle; + public PermissionServiceProxy(LPPermissionService handle) { + this.handle = handle; + } + + @Nonnull @Override public SubjectCollection getUserSubjects() { - return handle.getUserSubjects().sponge(); + return this.handle.getUserSubjects().sponge(); } + @Nonnull @Override public SubjectCollection getGroupSubjects() { - return handle.getGroupSubjects().sponge(); + return this.handle.getGroupSubjects().sponge(); } + @Nonnull @Override public Subject getDefaults() { - return handle.getDefaults().sponge(); + return this.handle.getDefaults().sponge(); } + @Nonnull @Override - public SubjectCollection getSubjects(String s) { - return handle.getCollection(s).sponge(); + public SubjectCollection getSubjects(@Nonnull String s) { + return this.handle.getCollection(s).sponge(); } + @Nonnull @Override public Map getKnownSubjects() { - return handle.getLoadedCollections().entrySet().stream() + return this.handle.getLoadedCollections().entrySet().stream() .collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> e.getValue().sponge() @@ -77,38 +85,40 @@ public final class PermissionServiceProxy implements PermissionService { } @Override - public Optional newDescriptionBuilder(Object o) { + public Optional newDescriptionBuilder(@Nonnull Object o) { Optional container = Sponge.getGame().getPluginManager().fromInstance(o); if (!container.isPresent()) { throw new IllegalArgumentException("Couldn't find a plugin container for " + o.getClass().getSimpleName()); } - return Optional.of(new SimpleDescriptionBuilder(handle, container.get())); + return Optional.of(new SimpleDescriptionBuilder(this.handle, container.get())); } + @Nonnull @Override - public Optional getDescription(String s) { - return handle.getDescription(s).map(LPPermissionDescription::sponge); + public Optional getDescription(@Nonnull String s) { + return this.handle.getDescription(s).map(LPPermissionDescription::sponge); } + @Nonnull @Override public Collection getDescriptions() { - return handle.getDescriptions().stream().map(LPPermissionDescription::sponge).collect(ImmutableCollectors.toSet()); + return this.handle.getDescriptions().stream().map(LPPermissionDescription::sponge).collect(ImmutableCollectors.toSet()); } @Override - public void registerContextCalculator(ContextCalculator contextCalculator) { - handle.registerContextCalculator(contextCalculator); + public void registerContextCalculator(@Nonnull ContextCalculator contextCalculator) { + this.handle.registerContextCalculator(contextCalculator); } @Override public boolean equals(Object o) { - return o == this || o instanceof PermissionServiceProxy && handle.equals(((PermissionServiceProxy) o).handle); + return o == this || o instanceof PermissionServiceProxy && this.handle.equals(((PermissionServiceProxy) o).handle); } @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } @Override diff --git a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SimpleDescriptionBuilder.java b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SimpleDescriptionBuilder.java index a29f16f6f..71636a9a5 100644 --- a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SimpleDescriptionBuilder.java +++ b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SimpleDescriptionBuilder.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api6; -import lombok.EqualsAndHashCode; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; @@ -44,57 +39,99 @@ import org.spongepowered.api.text.Text; import java.util.HashMap; import java.util.Map; +import java.util.Objects; + +import javax.annotation.Nonnull; -@ToString(of = {"container", "roles", "id", "description"}) -@EqualsAndHashCode(of = {"container", "roles", "id", "description"}) -@RequiredArgsConstructor public final class SimpleDescriptionBuilder implements PermissionDescription.Builder { - private final LPPermissionService service; - private final PluginContainer container; - private final Map roles = new HashMap<>(); + @Nonnull private final LPPermissionService service; + @Nonnull private final PluginContainer container; + @Nonnull private final Map roles = new HashMap<>(); private String id = null; private Text description = null; + public SimpleDescriptionBuilder(@Nonnull LPPermissionService service, @Nonnull PluginContainer container) { + this.service = Objects.requireNonNull(service, "service"); + this.container = Objects.requireNonNull(container, "container"); + } + + @Nonnull @Override - public PermissionDescription.Builder id(@NonNull String s) { - id = s; + public PermissionDescription.Builder id(@Nonnull String id) { + this.id = Objects.requireNonNull(id, "id"); return this; } + @Nonnull @Override - public PermissionDescription.Builder description(Text text) { - description = text; + public PermissionDescription.Builder description(@Nonnull Text description) { + this.description = Objects.requireNonNull(description, "description"); return this; } + @Nonnull @Override - public PermissionDescription.Builder assign(@NonNull String s, boolean b) { - roles.put(s, Tristate.fromBoolean(b)); + public PermissionDescription.Builder assign(@Nonnull String permission, boolean value) { + Objects.requireNonNull(permission, "permission"); + this.roles.put(permission, Tristate.fromBoolean(value)); return this; } + @Nonnull @Override public PermissionDescription register() throws IllegalStateException { - if (id == null) { + if (this.id == null) { throw new IllegalStateException("id cannot be null"); } - LPPermissionDescription d = service.registerPermissionDescription(id, description, container); + LPPermissionDescription d = this.service.registerPermissionDescription(this.id, this.description, this.container); // Set role-templates - LPSubjectCollection subjects = service.getCollection(PermissionService.SUBJECTS_ROLE_TEMPLATE); - for (Map.Entry assignment : roles.entrySet()) { + LPSubjectCollection subjects = this.service.getCollection(PermissionService.SUBJECTS_ROLE_TEMPLATE); + for (Map.Entry assignment : this.roles.entrySet()) { LPSubject subject = subjects.loadSubject(assignment.getKey()).join(); - subject.getTransientSubjectData().setPermission(ContextSet.empty(), id, assignment.getValue()); + subject.getTransientSubjectData().setPermission(ContextSet.empty(), this.id, assignment.getValue()); } - service.getPlugin().getPermissionVault().offer(id); + this.service.getPlugin().getPermissionVault().offer(this.id); // null stuff so this instance can be reused - roles.clear(); - id = null; - description = null; + this.roles.clear(); + this.id = null; + this.description = null; return d.sponge(); } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof SimpleDescriptionBuilder)) return false; + final SimpleDescriptionBuilder other = (SimpleDescriptionBuilder) o; + + return this.container.equals(other.container) && + this.roles.equals(other.roles) && + (this.id == null ? other.id == null : this.id.equals(other.id)) && + (this.description == null ? other.description == null : this.description.equals(other.description)); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.container.hashCode(); + result = result * PRIME + this.roles.hashCode(); + result = result * PRIME + (this.id == null ? 43 : this.id.hashCode()); + result = result * PRIME + (this.description == null ? 43 : this.description.hashCode()); + return result; + } + + @Override + public String toString() { + return "SimpleDescriptionBuilder(" + + "container=" + this.container + ", " + + "roles=" + this.roles + ", " + + "id=" + this.id + ", " + + "description=" + this.description + ")"; + } } diff --git a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectCollectionProxy.java b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectCollectionProxy.java index 5e6fa9acb..ce5d52592 100644 --- a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectCollectionProxy.java +++ b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectCollectionProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api6; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.CompatibilityUtil; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -42,77 +40,89 @@ import java.util.List; import java.util.Map; import java.util.Set; +import javax.annotation.Nonnull; + @SuppressWarnings("unchecked") -@RequiredArgsConstructor public final class SubjectCollectionProxy implements SubjectCollection { private final LPPermissionService service; private final LPSubjectCollection handle; + public SubjectCollectionProxy(LPPermissionService service, LPSubjectCollection handle) { + this.service = service; + this.handle = handle; + } + + @Nonnull @Override public String getIdentifier() { - return handle.getIdentifier(); + return this.handle.getIdentifier(); } + @Nonnull @Override - public Subject get(String s) { + public Subject get(@Nonnull String s) { // force load the subject. // after this call, users will expect that the subject is loaded in memory. - return handle.loadSubject(s).thenApply(LPSubject::sponge).join(); + return this.handle.loadSubject(s).thenApply(LPSubject::sponge).join(); } @Override - public boolean hasRegistered(String s) { - return handle.hasRegistered(s).join(); + public boolean hasRegistered(@Nonnull String s) { + return this.handle.hasRegistered(s).join(); } + @Nonnull @Override public Iterable getAllSubjects() { // this will lazily load all subjects. it will initially just get the identifiers of each subject, and will initialize dummy // providers for those identifiers. when any methods against the dummy are called, the actual data will be loaded. // this behaviour should be replaced when CompletableFutures are added to Sponge - return (List) handle.getAllIdentifiers() + return (List) this.handle.getAllIdentifiers() .thenApply(ids -> ids.stream() - .map(s -> new SubjectProxy(service, SubjectReferenceFactory.obtain(service, getIdentifier(), s))) + .map(s -> new SubjectProxy(this.service, SubjectReferenceFactory.obtain(this.service, getIdentifier(), s))) .collect(ImmutableCollectors.toList()) ).join(); } + @Nonnull @Override - public Map getAllWithPermission(String s) { + public Map getAllWithPermission(@Nonnull String s) { // again, these methods will lazily load subjects. - return (Map) handle.getAllWithPermission(s) + return (Map) this.handle.getAllWithPermission(s) .thenApply(map -> map.entrySet().stream() .collect(ImmutableCollectors.toMap( - e -> new SubjectProxy(service, e.getKey()), + e -> new SubjectProxy(this.service, e.getKey()), Map.Entry::getValue )) ).join(); } + @Nonnull @Override - public Map getAllWithPermission(Set set, String s) { - return (Map) handle.getAllWithPermission(CompatibilityUtil.convertContexts(set), s) + public Map getAllWithPermission(@Nonnull Set set, @Nonnull String s) { + return (Map) this.handle.getAllWithPermission(CompatibilityUtil.convertContexts(set), s) .thenApply(map -> map.entrySet().stream() .collect(ImmutableCollectors.toMap( - e -> new SubjectProxy(service, e.getKey()), + e -> new SubjectProxy(this.service, e.getKey()), Map.Entry::getValue )) ).join(); } + @Nonnull @Override public Subject getDefaults() { - return handle.getDefaults().sponge(); + return this.handle.getDefaults().sponge(); } @Override public boolean equals(Object o) { - return o == this || o instanceof SubjectCollectionProxy && handle.equals(((SubjectCollectionProxy) o).handle); + return o == this || o instanceof SubjectCollectionProxy && this.handle.equals(((SubjectCollectionProxy) o).handle); } @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } @Override diff --git a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectDataProxy.java b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectDataProxy.java index d745f10bb..05cd8ed4d 100644 --- a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectDataProxy.java +++ b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectDataProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api6; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.CompatibilityUtil; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -45,17 +43,25 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.CompletableFuture; +import javax.annotation.Nonnull; + @SuppressWarnings("unchecked") -@RequiredArgsConstructor public final class SubjectDataProxy implements SubjectData { private final LPPermissionService service; private final SubjectReference ref; private final boolean enduring; - private CompletableFuture handle() { - return enduring ? ref.resolveLp().thenApply(LPSubject::getSubjectData) : ref.resolveLp().thenApply(LPSubject::getTransientSubjectData); + public SubjectDataProxy(LPPermissionService service, SubjectReference ref, boolean enduring) { + this.service = service; + this.ref = ref; + this.enduring = enduring; } + private CompletableFuture handle() { + return this.enduring ? this.ref.resolveLp().thenApply(LPSubject::getSubjectData) : this.ref.resolveLp().thenApply(LPSubject::getTransientSubjectData); + } + + @Nonnull @Override public Map, Map> getAllPermissions() { return (Map) handle().thenApply(handle -> handle.getAllPermissions().entrySet().stream() @@ -65,13 +71,14 @@ public final class SubjectDataProxy implements SubjectData { ))).join(); } + @Nonnull @Override - public Map getPermissions(Set contexts) { + public Map getPermissions(@Nonnull Set contexts) { return handle().thenApply(handle -> handle.getPermissions(CompatibilityUtil.convertContexts(contexts))).join(); } @Override - public boolean setPermission(Set contexts, String permission, Tristate value) { + public boolean setPermission(@Nonnull Set contexts, @Nonnull String permission, @Nonnull Tristate value) { handle().thenCompose(handle -> handle.setPermission( CompatibilityUtil.convertContexts(contexts), permission, @@ -87,44 +94,46 @@ public final class SubjectDataProxy implements SubjectData { } @Override - public boolean clearPermissions(Set contexts) { + public boolean clearPermissions(@Nonnull Set contexts) { handle().thenCompose(handle -> handle.clearPermissions(CompatibilityUtil.convertContexts(contexts))); return true; } + @Nonnull @Override public Map, List> getAllParents() { return (Map) handle().thenApply(handle -> handle.getAllParents().entrySet().stream() .collect(ImmutableCollectors.toMap( e -> CompatibilityUtil.convertContexts(e.getKey()), e -> e.getValue().stream() - .map(s -> new SubjectProxy(service, s)) + .map(s -> new SubjectProxy(this.service, s)) .collect(ImmutableCollectors.toList()) ) )).join(); } + @Nonnull @Override - public List getParents(Set contexts) { + public List getParents(@Nonnull Set contexts) { return (List) handle().thenApply(handle -> handle.getParents(CompatibilityUtil.convertContexts(contexts)).stream() - .map(s -> new SubjectProxy(service, s)) + .map(s -> new SubjectProxy(this.service, s)) .collect(ImmutableCollectors.toList())).join(); } @Override - public boolean addParent(Set contexts, Subject parent) { + public boolean addParent(@Nonnull Set contexts, @Nonnull Subject parent) { handle().thenCompose(handle -> handle.addParent( CompatibilityUtil.convertContexts(contexts), - SubjectReferenceFactory.obtain(service, parent) + SubjectReferenceFactory.obtain(this.service, parent) )); return true; } @Override - public boolean removeParent(Set contexts, Subject parent) { + public boolean removeParent(@Nonnull Set contexts, @Nonnull Subject parent) { handle().thenCompose(handle -> handle.removeParent( CompatibilityUtil.convertContexts(contexts), - SubjectReferenceFactory.obtain(service, parent) + SubjectReferenceFactory.obtain(this.service, parent) )); return true; } @@ -136,11 +145,12 @@ public final class SubjectDataProxy implements SubjectData { } @Override - public boolean clearParents(Set contexts) { + public boolean clearParents(@Nonnull Set contexts) { handle().thenCompose(handle -> handle.clearParents(CompatibilityUtil.convertContexts(contexts))); return true; } + @Nonnull @Override public Map, Map> getAllOptions() { return (Map) handle().thenApply(handle -> handle.getAllOptions().entrySet().stream() @@ -150,13 +160,14 @@ public final class SubjectDataProxy implements SubjectData { ))).join(); } + @Nonnull @Override - public Map getOptions(Set contexts) { + public Map getOptions(@Nonnull Set contexts) { return handle().thenApply(handle -> handle.getOptions(CompatibilityUtil.convertContexts(contexts))).join(); } @Override - public boolean setOption(Set contexts, String key, String value) { + public boolean setOption(@Nonnull Set contexts, @Nonnull String key, String value) { if (value == null) { handle().thenCompose(handle -> handle.unsetOption(CompatibilityUtil.convertContexts(contexts), key)); return true; @@ -167,7 +178,7 @@ public final class SubjectDataProxy implements SubjectData { } @Override - public boolean clearOptions(Set contexts) { + public boolean clearOptions(@Nonnull Set contexts) { handle().thenCompose(handle -> handle.clearOptions(CompatibilityUtil.convertContexts(contexts))); return true; } diff --git a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectProxy.java b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectProxy.java index 579b03f12..2be20a83f 100644 --- a/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectProxy.java +++ b/sponge/sponge-service-api6/src/main/java/me/lucko/luckperms/sponge/service/proxy/api6/SubjectProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api6; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.CompatibilityUtil; @@ -48,101 +46,115 @@ import java.util.Optional; import java.util.Set; import java.util.concurrent.CompletableFuture; +import javax.annotation.Nonnull; + @SuppressWarnings("unchecked") -@RequiredArgsConstructor public final class SubjectProxy implements Subject, ProxiedSubject { private final LPPermissionService service; private final SubjectReference ref; + public SubjectProxy(LPPermissionService service, SubjectReference ref) { + this.service = service; + this.ref = ref; + } + private CompletableFuture handle() { - return ref.resolveLp(); + return this.ref.resolveLp(); } @Override public SubjectReference getReference() { - return ref; + return this.ref; } + @Nonnull @Override public Optional getCommandSource() { return handle().thenApply(LPSubject::getCommandSource).join(); } + @Nonnull @Override public SubjectCollection getContainingCollection() { - return service.getCollection(ref.getCollectionIdentifier()).sponge(); + return this.service.getCollection(this.ref.getCollectionIdentifier()).sponge(); } @Override public SubjectData getSubjectData() { - return new SubjectDataProxy(service, ref, true); + return new SubjectDataProxy(this.service, this.ref, true); } @Override public SubjectData getTransientSubjectData() { - return new SubjectDataProxy(service, ref, false); + return new SubjectDataProxy(this.service, this.ref, false); } @Override - public boolean hasPermission(Set contexts, String permission) { + public boolean hasPermission(@Nonnull Set contexts, @Nonnull String permission) { return handle().thenApply(handle -> handle.getPermissionValue(CompatibilityUtil.convertContexts(contexts), permission).asBoolean()).join(); } @Override - public boolean hasPermission(String permission) { + public boolean hasPermission(@Nonnull String permission) { return handle().thenApply(handle -> handle.getPermissionValue(ImmutableContextSet.empty(), permission).asBoolean()).join(); } + @Nonnull @Override - public Tristate getPermissionValue(Set contexts, String permission) { + public Tristate getPermissionValue(@Nonnull Set contexts, @Nonnull String permission) { return handle().thenApply(handle -> CompatibilityUtil.convertTristate(handle.getPermissionValue(CompatibilityUtil.convertContexts(contexts), permission))).join(); } @Override - public boolean isChildOf(Subject parent) { + public boolean isChildOf(@Nonnull Subject parent) { return handle().thenApply(handle -> handle.isChildOf( ImmutableContextSet.empty(), - SubjectReferenceFactory.obtain(service, parent) + SubjectReferenceFactory.obtain(this.service, parent) )).join(); } @Override - public boolean isChildOf(Set contexts, Subject parent) { + public boolean isChildOf(@Nonnull Set contexts, @Nonnull Subject parent) { return handle().thenApply(handle -> handle.isChildOf( CompatibilityUtil.convertContexts(contexts), - SubjectReferenceFactory.obtain(service, parent) + SubjectReferenceFactory.obtain(this.service, parent) )).join(); } + @Nonnull @Override public List getParents() { return (List) handle().thenApply(handle -> handle.getParents(ImmutableContextSet.empty()).stream() - .map(s -> new SubjectProxy(service, s)) + .map(s -> new SubjectProxy(this.service, s)) .collect(ImmutableCollectors.toList())).join(); } + @Nonnull @Override - public List getParents(Set contexts) { + public List getParents(@Nonnull Set contexts) { return (List) handle().thenApply(handle -> handle.getParents(CompatibilityUtil.convertContexts(contexts)).stream() - .map(s -> new SubjectProxy(service, s)) + .map(s -> new SubjectProxy(this.service, s)) .collect(ImmutableCollectors.toList())).join(); } + @Nonnull @Override - public Optional getOption(Set contexts, String key) { + public Optional getOption(@Nonnull Set contexts, @Nonnull String key) { return handle().thenApply(handle -> handle.getOption(CompatibilityUtil.convertContexts(contexts), key)).join(); } + @Nonnull @Override - public Optional getOption(String key) { + public Optional getOption(@Nonnull String key) { return handle().thenApply(handle -> handle.getOption(ImmutableContextSet.empty(), key)).join(); } @Override public String getIdentifier() { - return ref.getSubjectIdentifier(); + return this.ref.getSubjectIdentifier(); } + @Nonnull @Override public Set getActiveContexts() { return handle().thenApply(handle -> CompatibilityUtil.convertContexts(handle.getActiveContextSet())).join(); @@ -150,12 +162,12 @@ public final class SubjectProxy implements Subject, ProxiedSubject { @Override public boolean equals(Object o) { - return o == this || o instanceof SubjectProxy && ref.equals(((SubjectProxy) o).ref); + return o == this || o instanceof SubjectProxy && this.ref.equals(((SubjectProxy) o).ref); } @Override public int hashCode() { - return ref.hashCode(); + return this.ref.hashCode(); } @Override diff --git a/sponge/sponge-service-api7/pom.xml b/sponge/sponge-service-api7/pom.xml index 23fc3b7ad..f9e8f4c97 100644 --- a/sponge/sponge-service-api7/pom.xml +++ b/sponge/sponge-service-api7/pom.xml @@ -57,13 +57,6 @@ 7.0.0-SNAPSHOT provided - - - org.projectlombok - lombok - ${lombok.version} - provided - diff --git a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionDescriptionProxy.java b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionDescriptionProxy.java index 2d1445c6c..a1242511c 100644 --- a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionDescriptionProxy.java +++ b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionDescriptionProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api7; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -41,49 +39,60 @@ import java.util.Map; import java.util.Optional; import java.util.concurrent.CompletableFuture; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public final class PermissionDescriptionProxy implements PermissionDescription { private final LPPermissionService service; private final LPPermissionDescription handle; + public PermissionDescriptionProxy(LPPermissionService service, LPPermissionDescription handle) { + this.service = service; + this.handle = handle; + } + + @Nonnull @Override public String getId() { - return handle.getId(); + return this.handle.getId(); } + @Nonnull @Override public Optional getDescription() { - return handle.getDescription(); + return this.handle.getDescription(); } + @Nonnull @Override public Optional getOwner() { - return handle.getOwner(); + return this.handle.getOwner(); } + @Nonnull @Override - public Map getAssignedSubjects(String s) { - return handle.getAssignedSubjects(s).entrySet().stream() + public Map getAssignedSubjects(@Nonnull String s) { + return this.handle.getAssignedSubjects(s).entrySet().stream() .collect(ImmutableCollectors.toMap( - e -> new SubjectProxy(service, e.getKey().toReference()), + e -> new SubjectProxy(this.service, e.getKey().toReference()), Map.Entry::getValue )); } + @Nonnull @SuppressWarnings("unchecked") @Override - public CompletableFuture> findAssignedSubjects(String s) { - return (CompletableFuture) handle.findAssignedSubjects(s); + public CompletableFuture> findAssignedSubjects(@Nonnull String s) { + return (CompletableFuture) this.handle.findAssignedSubjects(s); } @Override public boolean equals(Object o) { - return o == this || o instanceof PermissionDescriptionProxy && handle.equals(((PermissionDescriptionProxy) o).handle); + return o == this || o instanceof PermissionDescriptionProxy && this.handle.equals(((PermissionDescriptionProxy) o).handle); } @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } @Override diff --git a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionServiceProxy.java b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionServiceProxy.java index 064dea28b..706d5cd1f 100644 --- a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionServiceProxy.java +++ b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/PermissionServiceProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api7; -import lombok.RequiredArgsConstructor; - import com.google.common.collect.ImmutableSet; import me.lucko.luckperms.common.utils.ImmutableCollectors; @@ -51,48 +49,59 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.function.Predicate; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public final class PermissionServiceProxy implements PermissionService { private final LPPermissionService handle; + public PermissionServiceProxy(LPPermissionService handle) { + this.handle = handle; + } + + @Nonnull @Override public SubjectCollection getUserSubjects() { - return handle.getUserSubjects().sponge(); + return this.handle.getUserSubjects().sponge(); } + @Nonnull @Override public SubjectCollection getGroupSubjects() { - return handle.getGroupSubjects().sponge(); + return this.handle.getGroupSubjects().sponge(); } + @Nonnull @Override public Subject getDefaults() { - return handle.getDefaults().sponge(); + return this.handle.getDefaults().sponge(); } + @Nonnull @Override public Predicate getIdentifierValidityPredicate() { - return handle.getIdentifierValidityPredicate(); + return this.handle.getIdentifierValidityPredicate(); } @Override - public CompletableFuture loadCollection(String s) { - return CompletableFuture.completedFuture(handle.getCollection(s).sponge()); + public CompletableFuture loadCollection(@Nonnull String s) { + return CompletableFuture.completedFuture(this.handle.getCollection(s).sponge()); } + @Nonnull @Override public Optional getCollection(String s) { - return Optional.ofNullable(handle.getLoadedCollections().get(s.toLowerCase())).map(LPSubjectCollection::sponge); + return Optional.ofNullable(this.handle.getLoadedCollections().get(s.toLowerCase())).map(LPSubjectCollection::sponge); } @Override public CompletableFuture hasCollection(String s) { - return CompletableFuture.completedFuture(handle.getLoadedCollections().containsKey(s.toLowerCase())); + return CompletableFuture.completedFuture(this.handle.getLoadedCollections().containsKey(s.toLowerCase())); } + @Nonnull @Override public Map getLoadedCollections() { - return handle.getLoadedCollections().entrySet().stream() + return this.handle.getLoadedCollections().entrySet().stream() .collect(ImmutableCollectors.toMap( Map.Entry::getKey, e -> e.getValue().sponge() @@ -101,47 +110,50 @@ public final class PermissionServiceProxy implements PermissionService { @Override public CompletableFuture> getAllIdentifiers() { - return CompletableFuture.completedFuture(ImmutableSet.copyOf(handle.getLoadedCollections().keySet())); + return CompletableFuture.completedFuture(ImmutableSet.copyOf(this.handle.getLoadedCollections().keySet())); + } + + @Nonnull + @Override + public SubjectReference newSubjectReference(@Nonnull String s, @Nonnull String s1) { + return SubjectReferenceFactory.obtain(this.handle, s, s1); } @Override - public SubjectReference newSubjectReference(String s, String s1) { - return SubjectReferenceFactory.obtain(handle, s, s1); - } - - @Override - public PermissionDescription.Builder newDescriptionBuilder(Object o) { + public PermissionDescription.Builder newDescriptionBuilder(@Nonnull Object o) { Optional container = Sponge.getGame().getPluginManager().fromInstance(o); if (!container.isPresent()) { throw new IllegalArgumentException("Couldn't find a plugin container for " + o.getClass().getSimpleName()); } - return new SimpleDescriptionBuilder(handle, container.get()); + return new SimpleDescriptionBuilder(this.handle, container.get()); } + @Nonnull @Override - public Optional getDescription(String s) { - return handle.getDescription(s).map(LPPermissionDescription::sponge); + public Optional getDescription(@Nonnull String s) { + return this.handle.getDescription(s).map(LPPermissionDescription::sponge); } + @Nonnull @Override public Collection getDescriptions() { - return handle.getDescriptions().stream().map(LPPermissionDescription::sponge).collect(ImmutableCollectors.toSet()); + return this.handle.getDescriptions().stream().map(LPPermissionDescription::sponge).collect(ImmutableCollectors.toSet()); } @Override - public void registerContextCalculator(ContextCalculator contextCalculator) { - handle.registerContextCalculator(contextCalculator); + public void registerContextCalculator(@Nonnull ContextCalculator contextCalculator) { + this.handle.registerContextCalculator(contextCalculator); } @Override public boolean equals(Object o) { - return o == this || o instanceof PermissionServiceProxy && handle.equals(((PermissionServiceProxy) o).handle); + return o == this || o instanceof PermissionServiceProxy && this.handle.equals(((PermissionServiceProxy) o).handle); } @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } @Override diff --git a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SimpleDescriptionBuilder.java b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SimpleDescriptionBuilder.java index ad4ca39e8..db8298b7a 100644 --- a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SimpleDescriptionBuilder.java +++ b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SimpleDescriptionBuilder.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api7; -import lombok.EqualsAndHashCode; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; @@ -44,57 +39,99 @@ import org.spongepowered.api.text.Text; import java.util.HashMap; import java.util.Map; +import java.util.Objects; + +import javax.annotation.Nonnull; -@ToString(of = {"container", "roles", "id", "description"}) -@EqualsAndHashCode(of = {"container", "roles", "id", "description"}) -@RequiredArgsConstructor public final class SimpleDescriptionBuilder implements PermissionDescription.Builder { - private final LPPermissionService service; - private final PluginContainer container; - private final Map roles = new HashMap<>(); + @Nonnull private final LPPermissionService service; + @Nonnull private final PluginContainer container; + @Nonnull private final Map roles = new HashMap<>(); private String id = null; private Text description = null; + public SimpleDescriptionBuilder(LPPermissionService service, PluginContainer container) { + this.service = Objects.requireNonNull(service, "service"); + this.container = Objects.requireNonNull(container, "container"); + } + + @Nonnull @Override - public PermissionDescription.Builder id(@NonNull String s) { - id = s; + public PermissionDescription.Builder id(@Nonnull String id) { + this.id = Objects.requireNonNull(id, "id"); return this; } + @Nonnull @Override - public PermissionDescription.Builder description(Text text) { - description = text; + public PermissionDescription.Builder description(Text description) { + this.description = Objects.requireNonNull(description, "description"); return this; } + @Nonnull @Override - public PermissionDescription.Builder assign(@NonNull String s, boolean b) { - roles.put(s, Tristate.fromBoolean(b)); + public PermissionDescription.Builder assign(@Nonnull String permission, boolean value) { + Objects.requireNonNull(permission, "permission"); + this.roles.put(permission, Tristate.fromBoolean(value)); return this; } + @Nonnull @Override public PermissionDescription register() throws IllegalStateException { - if (id == null) { + if (this.id == null) { throw new IllegalStateException("id cannot be null"); } - LPPermissionDescription d = service.registerPermissionDescription(id, description, container); + LPPermissionDescription d = this.service.registerPermissionDescription(this.id, this.description, this.container); // Set role-templates - LPSubjectCollection subjects = service.getCollection(PermissionService.SUBJECTS_ROLE_TEMPLATE); - for (Map.Entry assignment : roles.entrySet()) { + LPSubjectCollection subjects = this.service.getCollection(PermissionService.SUBJECTS_ROLE_TEMPLATE); + for (Map.Entry assignment : this.roles.entrySet()) { LPSubject subject = subjects.loadSubject(assignment.getKey()).join(); - subject.getTransientSubjectData().setPermission(ContextSet.empty(), id, assignment.getValue()); + subject.getTransientSubjectData().setPermission(ContextSet.empty(), this.id, assignment.getValue()); } - service.getPlugin().getPermissionVault().offer(id); + this.service.getPlugin().getPermissionVault().offer(this.id); // null stuff so this instance can be reused - roles.clear(); - id = null; - description = null; + this.roles.clear(); + this.id = null; + this.description = null; return d.sponge(); } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof SimpleDescriptionBuilder)) return false; + final SimpleDescriptionBuilder other = (SimpleDescriptionBuilder) o; + + return this.container.equals(other.container) && + this.roles.equals(other.roles) && + (this.id == null ? other.id == null : this.id.equals(other.id)) && + (this.description == null ? other.description == null : this.description.equals(other.description)); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.container.hashCode(); + result = result * PRIME + this.roles.hashCode(); + result = result * PRIME + (this.id == null ? 43 : this.id.hashCode()); + result = result * PRIME + (this.description == null ? 43 : this.description.hashCode()); + return result; + } + + @Override + public String toString() { + return "SimpleDescriptionBuilder(" + + "container=" + this.container + ", " + + "roles=" + this.roles + ", " + + "id=" + this.id + ", " + + "description=" + this.description + ")"; + } } diff --git a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectCollectionProxy.java b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectCollectionProxy.java index 2c14660dc..608972728 100644 --- a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectCollectionProxy.java +++ b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectCollectionProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api7; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.CompatibilityUtil; import me.lucko.luckperms.sponge.service.model.LPSubject; @@ -45,102 +43,121 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.function.Predicate; +import javax.annotation.Nonnull; + @SuppressWarnings("unchecked") -@RequiredArgsConstructor public final class SubjectCollectionProxy implements SubjectCollection { private final LPSubjectCollection handle; + public SubjectCollectionProxy(LPSubjectCollection handle) { + this.handle = handle; + } + + @Nonnull @Override public String getIdentifier() { - return handle.getIdentifier(); + return this.handle.getIdentifier(); } + @Nonnull @Override public Predicate getIdentifierValidityPredicate() { - return handle.getIdentifierValidityPredicate(); + return this.handle.getIdentifierValidityPredicate(); } + @Nonnull @Override - public CompletableFuture loadSubject(String s) { - return handle.loadSubject(s).thenApply(LPSubject::sponge); + public CompletableFuture loadSubject(@Nonnull String s) { + return this.handle.loadSubject(s).thenApply(LPSubject::sponge); } + @Nonnull @Override - public Optional getSubject(String s) { - return handle.getSubject(s).map(LPSubject::sponge); + public Optional getSubject(@Nonnull String s) { + return this.handle.getSubject(s).map(LPSubject::sponge); } + @Nonnull @Override - public CompletableFuture hasSubject(String s) { - return handle.hasRegistered(s); + public CompletableFuture hasSubject(@Nonnull String s) { + return this.handle.hasRegistered(s); } + @Nonnull @Override - public CompletableFuture> loadSubjects(Set set) { - return handle.loadSubjects(set).thenApply(subs -> subs.stream().collect(ImmutableCollectors.toMap(LPSubject::getIdentifier, LPSubject::sponge))); + public CompletableFuture> loadSubjects(@Nonnull Set set) { + return this.handle.loadSubjects(set).thenApply(subs -> subs.stream().collect(ImmutableCollectors.toMap(LPSubject::getIdentifier, LPSubject::sponge))); } + @Nonnull @Override public Collection getLoadedSubjects() { - return handle.getLoadedSubjects().stream().map(LPSubject::sponge).collect(ImmutableCollectors.toSet()); + return this.handle.getLoadedSubjects().stream().map(LPSubject::sponge).collect(ImmutableCollectors.toSet()); } + @Nonnull @Override public CompletableFuture> getAllIdentifiers() { - return (CompletableFuture) handle.getAllIdentifiers(); + return (CompletableFuture) this.handle.getAllIdentifiers(); } + @Nonnull @Override - public SubjectReference newSubjectReference(String s) { - return SubjectReferenceFactory.obtain(handle.getService(), getIdentifier(), s); + public SubjectReference newSubjectReference(@Nonnull String s) { + return SubjectReferenceFactory.obtain(this.handle.getService(), getIdentifier(), s); } + @Nonnull @Override - public CompletableFuture> getAllWithPermission(String s) { - return (CompletableFuture) handle.getAllWithPermission(s); + public CompletableFuture> getAllWithPermission(@Nonnull String s) { + return (CompletableFuture) this.handle.getAllWithPermission(s); } + @Nonnull @Override - public CompletableFuture> getAllWithPermission(Set set, String s) { - return (CompletableFuture) handle.getAllWithPermission(CompatibilityUtil.convertContexts(set), s); + public CompletableFuture> getAllWithPermission(@Nonnull Set set, @Nonnull String s) { + return (CompletableFuture) this.handle.getAllWithPermission(CompatibilityUtil.convertContexts(set), s); } + @Nonnull @Override - public Map getLoadedWithPermission(String s) { - return handle.getLoadedWithPermission(s).entrySet().stream() + public Map getLoadedWithPermission(@Nonnull String s) { + return this.handle.getLoadedWithPermission(s).entrySet().stream() .collect(ImmutableCollectors.toMap( sub -> sub.getKey().sponge(), Map.Entry::getValue )); } + @Nonnull @Override - public Map getLoadedWithPermission(Set set, String s) { - return handle.getLoadedWithPermission(CompatibilityUtil.convertContexts(set), s).entrySet().stream() + public Map getLoadedWithPermission(@Nonnull Set set, @Nonnull String s) { + return this.handle.getLoadedWithPermission(CompatibilityUtil.convertContexts(set), s).entrySet().stream() .collect(ImmutableCollectors.toMap( sub -> sub.getKey().sponge(), Map.Entry::getValue )); } + @Nonnull @Override public Subject getDefaults() { - return handle.getDefaults().sponge(); + return this.handle.getDefaults().sponge(); } @Override - public void suggestUnload(String s) { + public void suggestUnload(@Nonnull String s) { // unused by lp } @Override public boolean equals(Object o) { - return o == this || o instanceof SubjectCollectionProxy && handle.equals(((SubjectCollectionProxy) o).handle); + return o == this || o instanceof SubjectCollectionProxy && this.handle.equals(((SubjectCollectionProxy) o).handle); } @Override public int hashCode() { - return handle.hashCode(); + return this.handle.hashCode(); } @Override diff --git a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectDataProxy.java b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectDataProxy.java index e521e41e7..4b41cf685 100644 --- a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectDataProxy.java +++ b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectDataProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api7; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.utils.ImmutableCollectors; import me.lucko.luckperms.sponge.service.CompatibilityUtil; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -44,19 +42,26 @@ import java.util.Map; import java.util.Set; import java.util.concurrent.CompletableFuture; +import javax.annotation.Nonnull; import javax.annotation.Nullable; @SuppressWarnings("unchecked") -@RequiredArgsConstructor public final class SubjectDataProxy implements SubjectData { private final LPPermissionService service; private final SubjectReference ref; private final boolean enduring; - private CompletableFuture handle() { - return enduring ? ref.resolveLp().thenApply(LPSubject::getSubjectData) : ref.resolveLp().thenApply(LPSubject::getTransientSubjectData); + public SubjectDataProxy(LPPermissionService service, SubjectReference ref, boolean enduring) { + this.service = service; + this.ref = ref; + this.enduring = enduring; } + private CompletableFuture handle() { + return this.enduring ? this.ref.resolveLp().thenApply(LPSubject::getSubjectData) : this.ref.resolveLp().thenApply(LPSubject::getTransientSubjectData); + } + + @Nonnull @Override public Map, Map> getAllPermissions() { return (Map) handle().thenApply(handle -> handle.getAllPermissions().entrySet().stream() @@ -66,13 +71,15 @@ public final class SubjectDataProxy implements SubjectData { ))).join(); } + @Nonnull @Override - public Map getPermissions(Set contexts) { + public Map getPermissions(@Nonnull Set contexts) { return handle().thenApply(handle -> handle.getPermissions(CompatibilityUtil.convertContexts(contexts))).join(); } + @Nonnull @Override - public CompletableFuture setPermission(Set contexts, String permission, Tristate value) { + public CompletableFuture setPermission(@Nonnull Set contexts, @Nonnull String permission, @Nonnull Tristate value) { return handle().thenCompose(handle -> handle.setPermission( CompatibilityUtil.convertContexts(contexts), permission, @@ -80,16 +87,19 @@ public final class SubjectDataProxy implements SubjectData { )); } + @Nonnull @Override public CompletableFuture clearPermissions() { return handle().thenCompose(LPSubjectData::clearPermissions); } + @Nonnull @Override - public CompletableFuture clearPermissions(Set contexts) { + public CompletableFuture clearPermissions(@Nonnull Set contexts) { return handle().thenCompose(handle -> handle.clearPermissions(CompatibilityUtil.convertContexts(contexts))); } + @Nonnull @Override public Map, List> getAllParents() { return (Map) handle().thenApply(handle -> handle.getAllParents().entrySet().stream() @@ -99,31 +109,37 @@ public final class SubjectDataProxy implements SubjectData { ))).join(); } + @Nonnull @Override - public List getParents(Set contexts) { + public List getParents(@Nonnull Set contexts) { return (List) handle().thenApply(handle -> handle.getParents(CompatibilityUtil.convertContexts(contexts))).join(); } + @Nonnull @Override - public CompletableFuture addParent(Set contexts, org.spongepowered.api.service.permission.SubjectReference ref) { - return handle().thenCompose(handle -> handle.addParent(CompatibilityUtil.convertContexts(contexts), SubjectReferenceFactory.obtain(service, ref))); + public CompletableFuture addParent(@Nonnull Set contexts, @Nonnull org.spongepowered.api.service.permission.SubjectReference ref) { + return handle().thenCompose(handle -> handle.addParent(CompatibilityUtil.convertContexts(contexts), SubjectReferenceFactory.obtain(this.service, ref))); } + @Nonnull @Override - public CompletableFuture removeParent(Set contexts, org.spongepowered.api.service.permission.SubjectReference ref) { - return handle().thenCompose(handle -> handle.removeParent(CompatibilityUtil.convertContexts(contexts), SubjectReferenceFactory.obtain(service, ref))); + public CompletableFuture removeParent(@Nonnull Set contexts, @Nonnull org.spongepowered.api.service.permission.SubjectReference ref) { + return handle().thenCompose(handle -> handle.removeParent(CompatibilityUtil.convertContexts(contexts), SubjectReferenceFactory.obtain(this.service, ref))); } + @Nonnull @Override public CompletableFuture clearParents() { return handle().thenCompose(LPSubjectData::clearParents); } + @Nonnull @Override - public CompletableFuture clearParents(Set contexts) { + public CompletableFuture clearParents(@Nonnull Set contexts) { return handle().thenCompose(handle -> handle.clearParents(CompatibilityUtil.convertContexts(contexts))); } + @Nonnull @Override public Map, Map> getAllOptions() { return (Map) handle().thenApply(handle -> handle.getAllOptions().entrySet().stream() @@ -133,13 +149,15 @@ public final class SubjectDataProxy implements SubjectData { ))).join(); } + @Nonnull @Override - public Map getOptions(Set contexts) { + public Map getOptions(@Nonnull Set contexts) { return handle().thenApply(handle -> handle.getOptions(CompatibilityUtil.convertContexts(contexts))).join(); } + @Nonnull @Override - public CompletableFuture setOption(Set contexts, String key, @Nullable String value) { + public CompletableFuture setOption(@Nonnull Set contexts, @Nonnull String key, @Nullable String value) { if (value == null) { return handle().thenCompose(handle -> handle.unsetOption(CompatibilityUtil.convertContexts(contexts), key)); } else { @@ -147,13 +165,15 @@ public final class SubjectDataProxy implements SubjectData { } } + @Nonnull @Override public CompletableFuture clearOptions() { return handle().thenCompose(LPSubjectData::clearOptions); } + @Nonnull @Override - public CompletableFuture clearOptions(Set contexts) { + public CompletableFuture clearOptions(@Nonnull Set contexts) { return handle().thenCompose(handle -> handle.clearOptions(CompatibilityUtil.convertContexts(contexts))); } diff --git a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectProxy.java b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectProxy.java index 814643a17..477a440fc 100644 --- a/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectProxy.java +++ b/sponge/sponge-service-api7/src/main/java/me/lucko/luckperms/sponge/service/proxy/api7/SubjectProxy.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.proxy.api7; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.sponge.service.CompatibilityUtil; import me.lucko.luckperms.sponge.service.model.LPPermissionService; @@ -47,34 +45,43 @@ import java.util.Optional; import java.util.Set; import java.util.concurrent.CompletableFuture; +import javax.annotation.Nonnull; + @SuppressWarnings("unchecked") -@RequiredArgsConstructor public final class SubjectProxy implements Subject, ProxiedSubject { private final LPPermissionService service; private final SubjectReference ref; + public SubjectProxy(LPPermissionService service, SubjectReference ref) { + this.service = service; + this.ref = ref; + } + private CompletableFuture getHandle() { - return ref.resolveLp(); + return this.ref.resolveLp(); } @Override public SubjectReference getReference() { - return ref; + return this.ref; } + @Nonnull @Override public Optional getCommandSource() { return getHandle().thenApply(LPSubject::getCommandSource).join(); } + @Nonnull @Override public SubjectCollection getContainingCollection() { - return service.getCollection(ref.getCollectionIdentifier()).sponge(); + return this.service.getCollection(this.ref.getCollectionIdentifier()).sponge(); } + @Nonnull @Override public org.spongepowered.api.service.permission.SubjectReference asSubjectReference() { - return ref; + return this.ref; } @Override @@ -84,69 +91,76 @@ public final class SubjectProxy implements Subject, ProxiedSubject { @Override public SubjectData getSubjectData() { - return new SubjectDataProxy(service, ref, true); + return new SubjectDataProxy(this.service, this.ref, true); } @Override public SubjectData getTransientSubjectData() { - return new SubjectDataProxy(service, ref, false); + return new SubjectDataProxy(this.service, this.ref, false); } @Override - public boolean hasPermission(Set contexts, String permission) { + public boolean hasPermission(@Nonnull Set contexts, @Nonnull String permission) { return getHandle().thenApply(handle -> handle.getPermissionValue(CompatibilityUtil.convertContexts(contexts), permission).asBoolean()).join(); } @Override - public boolean hasPermission(String permission) { + public boolean hasPermission(@Nonnull String permission) { return getHandle().thenApply(handle -> handle.getPermissionValue(ImmutableContextSet.empty(), permission).asBoolean()).join(); } + @Nonnull @Override - public Tristate getPermissionValue(Set contexts, String permission) { + public Tristate getPermissionValue(@Nonnull Set contexts, @Nonnull String permission) { return getHandle().thenApply(handle -> CompatibilityUtil.convertTristate(handle.getPermissionValue(CompatibilityUtil.convertContexts(contexts), permission))).join(); } @Override - public boolean isChildOf(org.spongepowered.api.service.permission.SubjectReference parent) { - return getHandle().thenApply(handle -> handle.isChildOf(ImmutableContextSet.empty(), SubjectReferenceFactory.obtain(service, parent))).join(); + public boolean isChildOf(@Nonnull org.spongepowered.api.service.permission.SubjectReference parent) { + return getHandle().thenApply(handle -> handle.isChildOf(ImmutableContextSet.empty(), SubjectReferenceFactory.obtain(this.service, parent))).join(); } @Override - public boolean isChildOf(Set contexts, org.spongepowered.api.service.permission.SubjectReference parent) { - return getHandle().thenApply(handle -> handle.isChildOf(CompatibilityUtil.convertContexts(contexts), SubjectReferenceFactory.obtain(service, parent))).join(); + public boolean isChildOf(@Nonnull Set contexts, @Nonnull org.spongepowered.api.service.permission.SubjectReference parent) { + return getHandle().thenApply(handle -> handle.isChildOf(CompatibilityUtil.convertContexts(contexts), SubjectReferenceFactory.obtain(this.service, parent))).join(); } + @Nonnull @Override public List getParents() { return (List) getHandle().thenApply(handle -> handle.getParents(ImmutableContextSet.empty())).join(); } + @Nonnull @Override - public List getParents(Set contexts) { + public List getParents(@Nonnull Set contexts) { return (List) getHandle().thenApply(handle -> handle.getParents(CompatibilityUtil.convertContexts(contexts))).join(); } + @Nonnull @Override - public Optional getOption(Set contexts, String key) { + public Optional getOption(@Nonnull Set contexts, @Nonnull String key) { return getHandle().thenApply(handle -> handle.getOption(CompatibilityUtil.convertContexts(contexts), key)).join(); } + @Nonnull @Override - public Optional getOption(String key) { + public Optional getOption(@Nonnull String key) { return getHandle().thenApply(handle -> handle.getOption(ImmutableContextSet.empty(), key)).join(); } @Override public String getIdentifier() { - return ref.getSubjectIdentifier(); + return this.ref.getSubjectIdentifier(); } + @Nonnull @Override public Optional getFriendlyIdentifier() { return getHandle().thenApply(LPSubject::getFriendlyIdentifier).join(); } + @Nonnull @Override public Set getActiveContexts() { return getHandle().thenApply(handle -> CompatibilityUtil.convertContexts(handle.getActiveContextSet())).join(); @@ -154,12 +168,12 @@ public final class SubjectProxy implements Subject, ProxiedSubject { @Override public boolean equals(Object o) { - return o == this || o instanceof SubjectProxy && ref.equals(((SubjectProxy) o).ref); + return o == this || o instanceof SubjectProxy && this.ref.equals(((SubjectProxy) o).ref); } @Override public int hashCode() { - return ref.hashCode(); + return this.ref.hashCode(); } @Override diff --git a/sponge/sponge-service/pom.xml b/sponge/sponge-service/pom.xml index 741a7a14e..4ca070942 100644 --- a/sponge/sponge-service/pom.xml +++ b/sponge/sponge-service/pom.xml @@ -58,13 +58,6 @@ 21.0 provided - - - org.projectlombok - lombok - ${lombok.version} - provided - diff --git a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/CompatibilityUtil.java b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/CompatibilityUtil.java index bb841edb2..0fd192b54 100644 --- a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/CompatibilityUtil.java +++ b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/CompatibilityUtil.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.sponge.service; -import lombok.NonNull; -import lombok.experimental.UtilityClass; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.collect.ImmutableSet; @@ -40,14 +37,14 @@ import me.lucko.luckperms.sponge.service.context.DelegatingImmutableContextSet; import org.spongepowered.api.service.context.Context; +import java.util.Objects; import java.util.Set; import java.util.concurrent.TimeUnit; /** * Utility class for converting between Sponge and LuckPerms context and tristate classes */ -@UtilityClass -public class CompatibilityUtil { +public final class CompatibilityUtil { private static final LoadingCache, ImmutableContextSet> SPONGE_TO_LP_CACHE = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) .build(ImmutableContextSet::fromEntries); @@ -56,7 +53,9 @@ public class CompatibilityUtil { .expireAfterAccess(10, TimeUnit.MINUTES) .build(DelegatingImmutableContextSet::new); - public static ImmutableContextSet convertContexts(@NonNull Set contexts) { + public static ImmutableContextSet convertContexts(Set contexts) { + Objects.requireNonNull(contexts, "contexts"); + if (contexts instanceof DelegatingContextSet) { return ((DelegatingContextSet) contexts).getDelegate().makeImmutable(); } @@ -64,11 +63,13 @@ public class CompatibilityUtil { return SPONGE_TO_LP_CACHE.get(ImmutableSet.copyOf(contexts)); } - public static Set convertContexts(@NonNull ContextSet contexts) { + public static Set convertContexts(ContextSet contexts) { + Objects.requireNonNull(contexts, "contexts"); return LP_TO_SPONGE_CACHE.get(contexts.makeImmutable()); } public static org.spongepowered.api.util.Tristate convertTristate(Tristate tristate) { + Objects.requireNonNull(tristate, "tristate"); switch (tristate) { case TRUE: return org.spongepowered.api.util.Tristate.TRUE; @@ -80,6 +81,7 @@ public class CompatibilityUtil { } public static Tristate convertTristate(org.spongepowered.api.util.Tristate tristate) { + Objects.requireNonNull(tristate, "tristate"); switch (tristate) { case TRUE: return Tristate.TRUE; @@ -90,4 +92,6 @@ public class CompatibilityUtil { } } + private CompatibilityUtil() {} + } diff --git a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingImmutableContextSet.java b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingImmutableContextSet.java index 106e7701b..b2e92f864 100644 --- a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingImmutableContextSet.java +++ b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingImmutableContextSet.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.sponge.service.context; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import me.lucko.luckperms.api.context.ImmutableContextSet; import org.spongepowered.api.service.context.Context; @@ -36,38 +33,43 @@ import java.util.Iterator; import java.util.Map; import java.util.Set; +import javax.annotation.Nonnull; + /** * Implements a {@link Set} of {@link Context}s, delegating all calls to a {@link ImmutableContextSet}. */ -@ToString -@RequiredArgsConstructor public class DelegatingImmutableContextSet extends AbstractDelegatingContextSet { private final ImmutableContextSet delegate; + public DelegatingImmutableContextSet(ImmutableContextSet delegate) { + this.delegate = delegate; + } + @Override public ImmutableContextSet getDelegate() { - return delegate; + return this.delegate; } @Override public int size() { - return delegate.size(); + return this.delegate.size(); } @Override public boolean isEmpty() { - return delegate.isEmpty(); + return this.delegate.isEmpty(); } @Override public boolean contains(Object o) { if (o instanceof Context) { Context context = (Context) o; - return delegate.has(context); + return this.delegate.has(context); } return false; } + @Nonnull @Override public Iterator iterator() { return new ContextSetIterator(); @@ -88,17 +90,22 @@ public class DelegatingImmutableContextSet extends AbstractDelegatingContextSet throw new UnsupportedOperationException("context set is immutable"); } + @Override + public String toString() { + return "DelegatingImmutableContextSet(delegate=" + this.getDelegate() + ")"; + } + private final class ContextSetIterator implements Iterator { - private final Iterator> it = delegate.toSet().iterator(); + private final Iterator> it = DelegatingImmutableContextSet.this.delegate.toSet().iterator(); @Override public boolean hasNext() { - return it.hasNext(); + return this.it.hasNext(); } @Override public Context next() { - Map.Entry next = it.next(); + Map.Entry next = this.it.next(); return new Context(next.getKey(), next.getValue()); } diff --git a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingMutableContextSet.java b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingMutableContextSet.java index 683943c64..80750a719 100644 --- a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingMutableContextSet.java +++ b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/context/DelegatingMutableContextSet.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.context; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.context.MutableContextSet; import org.spongepowered.api.service.context.Context; @@ -35,37 +33,43 @@ import java.util.Iterator; import java.util.Map; import java.util.Set; +import javax.annotation.Nonnull; + /** * Implements a {@link Set} of {@link Context}s, delegating all calls to a {@link MutableContextSet}. */ -@RequiredArgsConstructor public class DelegatingMutableContextSet extends AbstractDelegatingContextSet { private final MutableContextSet delegate; + public DelegatingMutableContextSet(MutableContextSet delegate) { + this.delegate = delegate; + } + @Override public MutableContextSet getDelegate() { - return delegate; + return this.delegate; } @Override public int size() { - return delegate.size(); + return this.delegate.size(); } @Override public boolean isEmpty() { - return delegate.isEmpty(); + return this.delegate.isEmpty(); } @Override public boolean contains(Object o) { if (o instanceof Context) { Context context = (Context) o; - return delegate.has(context); + return this.delegate.has(context); } return false; } + @Nonnull @Override public Iterator iterator() { return new ContextSetIterator(); @@ -77,8 +81,8 @@ public class DelegatingMutableContextSet extends AbstractDelegatingContextSet { throw new NullPointerException("context"); } - boolean has = delegate.has(context); - delegate.add(context); + boolean has = this.delegate.has(context); + this.delegate.add(context); return !has; } @@ -86,8 +90,8 @@ public class DelegatingMutableContextSet extends AbstractDelegatingContextSet { public boolean remove(Object o) { if (o instanceof Context) { Context context = (Context) o; - boolean had = delegate.has(context); - delegate.remove(context.getKey(), context.getValue()); + boolean had = this.delegate.has(context); + this.delegate.remove(context.getKey(), context.getValue()); return had; } @@ -96,38 +100,43 @@ public class DelegatingMutableContextSet extends AbstractDelegatingContextSet { @Override public void clear() { - delegate.clear(); + this.delegate.clear(); + } + + @Override + public String toString() { + return "DelegatingMutableContextSet(delegate=" + this.getDelegate() + ")"; } private final class ContextSetIterator implements Iterator { - private final Iterator> it = delegate.toSet().iterator(); + private final Iterator> it = DelegatingMutableContextSet.this.delegate.toSet().iterator(); private Context current; @Override public boolean hasNext() { - return it.hasNext(); + return this.it.hasNext(); } @Override public Context next() { - Map.Entry next = it.next(); + Map.Entry next = this.it.next(); // track the iterators cursor to handle #remove calls - current = new Context(next.getKey(), next.getValue()); - return current; + this.current = new Context(next.getKey(), next.getValue()); + return this.current; } @Override public void remove() { - Context c = current; + Context c = this.current; if (c == null) { throw new IllegalStateException(); } - current = null; + this.current = null; // delegate the removal call to the MutableContextSet, as the iterator returned by // toSet().iterator() is immutable - delegate.remove(c.getKey(), c.getValue()); + DelegatingMutableContextSet.this.delegate.remove(c.getKey(), c.getValue()); } } } diff --git a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReference.java b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReference.java index 7aef25a95..d8c6abd0f 100644 --- a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReference.java +++ b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReference.java @@ -25,13 +25,10 @@ package me.lucko.luckperms.sponge.service.model; -import lombok.Getter; - -import com.google.common.base.Preconditions; - import org.spongepowered.api.service.permission.Subject; import java.lang.ref.WeakReference; +import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit; @@ -58,14 +55,12 @@ public final class SubjectReference implements org.spongepowered.api.service.per /** * The identifier of the collection which holds the subject */ - @Getter @Nonnull private final String collectionIdentifier; /** * The identifier of the subject */ - @Getter @Nonnull private final String subjectIdentifier; @@ -74,9 +69,21 @@ public final class SubjectReference implements org.spongepowered.api.service.per private WeakReference cache = null; SubjectReference(LPPermissionService service, String collectionIdentifier, String subjectIdentifier) { - this.service = Preconditions.checkNotNull(service); - this.collectionIdentifier = Preconditions.checkNotNull(collectionIdentifier); - this.subjectIdentifier = Preconditions.checkNotNull(subjectIdentifier); + this.service = Objects.requireNonNull(service); + this.collectionIdentifier = Objects.requireNonNull(collectionIdentifier); + this.subjectIdentifier = Objects.requireNonNull(subjectIdentifier); + } + + @Nonnull + @Override + public String getCollectionIdentifier() { + return this.collectionIdentifier; + } + + @Nonnull + @Override + public String getSubjectIdentifier() { + return this.subjectIdentifier; } void fillCache(LPSubject subject) { @@ -84,18 +91,18 @@ public final class SubjectReference implements org.spongepowered.api.service.per if (sub == null) { // if no value is currently cached, populate with the passed value - lastLookup = System.currentTimeMillis(); - cache = new WeakReference<>(subject); + this.lastLookup = System.currentTimeMillis(); + this.cache = new WeakReference<>(subject); } else if (sub == subject) { // if equal, reset the cache timeout - lastLookup = System.currentTimeMillis(); + this.lastLookup = System.currentTimeMillis(); } } private LPSubject tryCache() { - if ((System.currentTimeMillis() - lastLookup) < CACHE_TIME) { - if (cache != null) { - return cache.get(); + if ((System.currentTimeMillis() - this.lastLookup) < CACHE_TIME) { + if (this.cache != null) { + return this.cache.get(); } } @@ -115,11 +122,11 @@ public final class SubjectReference implements org.spongepowered.api.service.per } // subject isn't cached, so make a call to load it - s = service.getCollection(collectionIdentifier).loadSubject(subjectIdentifier).join(); + s = this.service.getCollection(this.collectionIdentifier).loadSubject(this.subjectIdentifier).join(); // cache the result - lastLookup = System.currentTimeMillis(); - cache = new WeakReference<>(s); + this.lastLookup = System.currentTimeMillis(); + this.cache = new WeakReference<>(s); return s; } @@ -134,6 +141,7 @@ public final class SubjectReference implements org.spongepowered.api.service.per return CompletableFuture.supplyAsync(this::resolveDirectly); } + @Nonnull @Override public CompletableFuture resolve() { // check if there is a cached value before loading diff --git a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReferenceFactory.java b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReferenceFactory.java index aac19b9f3..9c6c83e55 100644 --- a/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReferenceFactory.java +++ b/sponge/sponge-service/src/main/java/me/lucko/luckperms/sponge/service/model/SubjectReferenceFactory.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.sponge.service.model; -import lombok.AllArgsConstructor; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.base.Splitter; @@ -36,34 +32,39 @@ import com.google.common.base.Splitter; import org.spongepowered.api.service.permission.Subject; import java.util.List; +import java.util.Objects; import java.util.concurrent.TimeUnit; /** * Caches the creation of {@link SubjectReference}s. */ -@RequiredArgsConstructor public final class SubjectReferenceFactory { // static util access @Deprecated - public static SubjectReference deserialize(@NonNull LPPermissionService service, String serialisedReference) { + public static SubjectReference deserialize(LPPermissionService service, String serialisedReference) { + Objects.requireNonNull(service, "service"); return service.getReferenceFactory().deserialize(serialisedReference); } - public static SubjectReference obtain(@NonNull LPPermissionService service, LPSubject subject) { + public static SubjectReference obtain(LPPermissionService service, LPSubject subject) { + Objects.requireNonNull(service, "service"); return service.getReferenceFactory().obtain(subject); } - public static SubjectReference obtain(@NonNull LPPermissionService service, Subject subject) { + public static SubjectReference obtain(LPPermissionService service, Subject subject) { + Objects.requireNonNull(service, "service"); return service.getReferenceFactory().obtain(subject); } - public static SubjectReference obtain(@NonNull LPPermissionService service, org.spongepowered.api.service.permission.SubjectReference reference) { + public static SubjectReference obtain(LPPermissionService service, org.spongepowered.api.service.permission.SubjectReference reference) { + Objects.requireNonNull(service, "service"); return service.getReferenceFactory().obtain(reference); } - public static SubjectReference obtain(@NonNull LPPermissionService service, String collectionIdentifier, String subjectIdentifier) { + public static SubjectReference obtain(LPPermissionService service, String collectionIdentifier, String subjectIdentifier) { + Objects.requireNonNull(service, "service"); return service.getReferenceFactory().obtain(collectionIdentifier, subjectIdentifier); } @@ -85,19 +86,26 @@ public final class SubjectReferenceFactory { .expireAfterAccess(1, TimeUnit.HOURS) .build(a -> new SubjectReference(SubjectReferenceFactory.this.service, a.collectionId, a.id)); + public SubjectReferenceFactory(LPPermissionService service) { + this.service = service; + } + @Deprecated - public SubjectReference deserialize(@NonNull String serialisedReference) { + public SubjectReference deserialize(String serialisedReference) { + Objects.requireNonNull(serialisedReference, "serialisedReference"); List parts = Splitter.on('/').limit(2).splitToList(serialisedReference); return obtain(parts.get(0), parts.get(1)); } - public SubjectReference obtain(@NonNull LPSubject subject) { + public SubjectReference obtain(LPSubject subject) { + Objects.requireNonNull(subject, "subject"); SubjectReference ret = obtain(subject.getParentCollection().getIdentifier(), subject.getIdentifier()); ret.fillCache(subject); return ret; } - public SubjectReference obtain(@NonNull Subject subject) { + public SubjectReference obtain(Subject subject) { + Objects.requireNonNull(subject, "subject"); if (subject instanceof ProxiedSubject) { return ((ProxiedSubject) subject).getReference(); } @@ -105,7 +113,8 @@ public final class SubjectReferenceFactory { return obtain(subject.getContainingCollection().getIdentifier(), subject.getIdentifier()); } - public SubjectReference obtain(@NonNull org.spongepowered.api.service.permission.SubjectReference reference) { + public SubjectReference obtain(org.spongepowered.api.service.permission.SubjectReference reference) { + Objects.requireNonNull(reference, "reference"); if (reference instanceof SubjectReference) { return ((SubjectReference) reference); } else { @@ -113,18 +122,24 @@ public final class SubjectReferenceFactory { } } - public SubjectReference obtain(@NonNull String collectionIdentifier, @NonNull String subjectIdentifier) { - return referenceCache.get(new SubjectReferenceAttributes(collectionIdentifier, subjectIdentifier)); + public SubjectReference obtain(String collectionIdentifier, String subjectIdentifier) { + Objects.requireNonNull(collectionIdentifier, "collectionIdentifier"); + Objects.requireNonNull(subjectIdentifier, "subjectIdentifier"); + return this.referenceCache.get(new SubjectReferenceAttributes(collectionIdentifier, subjectIdentifier)); } /** * Used as a cache key. */ - @AllArgsConstructor private static final class SubjectReferenceAttributes { private final String collectionId; private final String id; + public SubjectReferenceAttributes(String collectionId, String id) { + this.collectionId = collectionId; + this.id = id; + } + @Override public boolean equals(Object o) { if (o == this) return true; diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java b/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java index 024dd89e9..f566ef001 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/LPSpongePlugin.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge; -import lombok.Getter; - import com.google.inject.Inject; import me.lucko.luckperms.api.Contexts; @@ -129,7 +127,6 @@ import java.util.stream.Stream; /** * LuckPerms implementation for the Sponge API. */ -@Getter @Plugin( id = "luckperms", name = "LuckPerms", @@ -194,97 +191,97 @@ public class LPSpongePlugin implements LuckPermsPlugin { @Listener(order = Order.FIRST) public void onEnable(GamePreInitializationEvent event) { - startTime = System.currentTimeMillis(); - scheduler = new SpongeSchedulerAdapter(this); - localeManager = new NoopLocaleManager(); - senderFactory = new SpongeSenderFactory(this); - log = new SenderLogger(this, getConsoleSender()); - dependencyManager = new DependencyManager(this); + this.startTime = System.currentTimeMillis(); + this.scheduler = new SpongeSchedulerAdapter(this); + this.localeManager = new NoopLocaleManager(); + this.senderFactory = new SpongeSenderFactory(this); + this.log = new SenderLogger(this, getConsoleSender()); + this.dependencyManager = new DependencyManager(this); sendStartupBanner(getConsoleSender()); - verboseHandler = new VerboseHandler(scheduler.async(), getVersion()); - permissionVault = new PermissionVault(scheduler.async()); - logDispatcher = new LogDispatcher(this); + this.verboseHandler = new VerboseHandler(this.scheduler.async(), getVersion()); + this.permissionVault = new PermissionVault(this.scheduler.async()); + this.logDispatcher = new LogDispatcher(this); getLog().info("Loading configuration..."); - configuration = new AbstractConfiguration(this, new SpongeConfigAdapter(this, resolveConfig("luckperms.conf"))); - configuration.loadAll(); + this.configuration = new AbstractConfiguration(this, new SpongeConfigAdapter(this, resolveConfig("luckperms.conf"))); + this.configuration.loadAll(); StorageFactory storageFactory = new StorageFactory(this); Set storageTypes = storageFactory.getRequiredTypes(StorageType.H2); - dependencyManager.loadStorageDependencies(storageTypes); + this.dependencyManager.loadStorageDependencies(storageTypes); // register events - game.getEventManager().registerListeners(this, new SpongeConnectionListener(this)); - game.getEventManager().registerListeners(this, new SpongePlatformListener(this)); + this.game.getEventManager().registerListeners(this, new SpongeConnectionListener(this)); + this.game.getEventManager().registerListeners(this, new SpongePlatformListener(this)); if (getConfiguration().get(ConfigKeys.WATCH_FILES)) { - fileWatcher = new FileWatcher(this); - getScheduler().asyncRepeating(fileWatcher, 30L); + this.fileWatcher = new FileWatcher(this); + getScheduler().asyncRepeating(this.fileWatcher, 30L); } // initialise datastore - storage = storageFactory.getInstance(StorageType.H2); + this.storage = storageFactory.getInstance(StorageType.H2); // initialise messaging - messagingService = new SpongeMessagingFactory(this).getInstance(); + this.messagingService = new SpongeMessagingFactory(this).getInstance(); // setup the update task buffer - updateTaskBuffer = new UpdateTaskBuffer(this); + this.updateTaskBuffer = new UpdateTaskBuffer(this); // load locale - localeManager = new SimpleLocaleManager(); - localeManager.tryLoad(this, new File(getDataDirectory(), "lang.yml")); + this.localeManager = new SimpleLocaleManager(); + this.localeManager.tryLoad(this, new File(getDataDirectory(), "lang.yml")); // register commands - CommandManager cmdService = game.getCommandManager(); - commandManager = new SpongeCommandExecutor(this); - cmdService.register(this, commandManager, "luckperms", "lp", "perm", "perms", "permission", "permissions"); + CommandManager cmdService = this.game.getCommandManager(); + this.commandManager = new SpongeCommandExecutor(this); + cmdService.register(this, this.commandManager, "luckperms", "lp", "perm", "perms", "permission", "permissions"); // load internal managers getLog().info("Loading internal permission managers..."); - uuidCache = new UuidCache(this); - userManager = new SpongeUserManager(this); - groupManager = new SpongeGroupManager(this); - trackManager = new GenericTrackManager(this); - calculatorFactory = new SpongeCalculatorFactory(this); - cachedStateManager = new CachedStateManager(); + this.uuidCache = new UuidCache(this); + this.userManager = new SpongeUserManager(this); + this.groupManager = new SpongeGroupManager(this); + this.trackManager = new GenericTrackManager(this); + this.calculatorFactory = new SpongeCalculatorFactory(this); + this.cachedStateManager = new CachedStateManager(); // setup context manager - contextManager = new SpongeContextManager(this); - contextManager.registerCalculator(new WorldCalculator(this)); - contextManager.registerStaticCalculator(new LuckPermsCalculator(getConfiguration())); + this.contextManager = new SpongeContextManager(this); + this.contextManager.registerCalculator(new WorldCalculator(this)); + this.contextManager.registerStaticCalculator(new LuckPermsCalculator(getConfiguration())); // register the PermissionService with Sponge getLog().info("Registering PermissionService..."); - service = new LuckPermsService(this); + this.service = new LuckPermsService(this); - if (game.getPluginManager().getPlugin("permissionsex").isPresent()) { + if (this.game.getPluginManager().getPlugin("permissionsex").isPresent()) { getLog().warn("Detected PermissionsEx - assuming it's loaded for migration."); getLog().warn("Delaying LuckPerms PermissionService registration."); - lateLoad = true; + this.lateLoad = true; } else { - game.getServiceManager().setProvider(this, LPPermissionService.class, service); - game.getServiceManager().setProvider(this, PermissionService.class, service.sponge()); - game.getServiceManager().setProvider(this, LuckPermsService.class, service); + this.game.getServiceManager().setProvider(this, LPPermissionService.class, this.service); + this.game.getServiceManager().setProvider(this, PermissionService.class, this.service.sponge()); + this.game.getServiceManager().setProvider(this, LuckPermsService.class, this.service); } // register with the LP API - apiProvider = new LuckPermsApiProvider(this); + this.apiProvider = new LuckPermsApiProvider(this); // setup event factory - eventFactory = new EventFactory(this, apiProvider); + this.eventFactory = new EventFactory(this, this.apiProvider); - ApiRegistrationUtil.registerProvider(apiProvider); - game.getServiceManager().setProvider(this, LuckPermsApi.class, apiProvider); + ApiRegistrationUtil.registerProvider(this.apiProvider); + this.game.getServiceManager().setProvider(this, LuckPermsApi.class, this.apiProvider); // schedule update tasks int mins = getConfiguration().get(ConfigKeys.SYNC_TIME); if (mins > 0) { long ticks = mins * 60 * 20; - scheduler.asyncRepeating(() -> updateTaskBuffer.request(), ticks); + this.scheduler.asyncRepeating(() -> this.updateTaskBuffer.request(), ticks); } - scheduler.asyncLater(() -> updateTaskBuffer.request(), 40L); + this.scheduler.asyncLater(() -> this.updateTaskBuffer.request(), 40L); // run an update instantly. getLog().info("Performing initial data load..."); @@ -295,69 +292,69 @@ public class LPSpongePlugin implements LuckPermsPlugin { } // register tasks - scheduler.asyncRepeating(new ExpireTemporaryTask(this), 60L); - scheduler.asyncRepeating(new CacheHousekeepingTask(this), 2400L); - scheduler.asyncRepeating(new ServiceCacheHousekeepingTask(service), 2400L); + this.scheduler.asyncRepeating(new ExpireTemporaryTask(this), 60L); + this.scheduler.asyncRepeating(new CacheHousekeepingTask(this), 2400L); + this.scheduler.asyncRepeating(new ServiceCacheHousekeepingTask(this.service), 2400L); // register permissions for (CommandPermission perm : CommandPermission.values()) { - service.registerPermissionDescription(perm.getPermission(), null, pluginContainer); + this.service.registerPermissionDescription(perm.getPermission(), null, this.pluginContainer); } - getLog().info("Successfully enabled. (took " + (System.currentTimeMillis() - startTime) + "ms)"); + getLog().info("Successfully enabled. (took " + (System.currentTimeMillis() - this.startTime) + "ms)"); } @Listener(order = Order.LATE) public void onLateEnable(GamePreInitializationEvent event) { - if (lateLoad) { + if (this.lateLoad) { getLog().info("Providing late registration of PermissionService..."); - game.getServiceManager().setProvider(this, LPPermissionService.class, service); - game.getServiceManager().setProvider(this, PermissionService.class, service.sponge()); - game.getServiceManager().setProvider(this, LuckPermsService.class, service); + this.game.getServiceManager().setProvider(this, LPPermissionService.class, this.service); + this.game.getServiceManager().setProvider(this, PermissionService.class, this.service.sponge()); + this.game.getServiceManager().setProvider(this, LuckPermsService.class, this.service); } } @Listener public void onDisable(GameStoppingServerEvent event) { - permissionVault.shutdown(); - verboseHandler.shutdown(); + this.permissionVault.shutdown(); + this.verboseHandler.shutdown(); getLog().info("Closing storage..."); - storage.shutdown(); + this.storage.shutdown(); - if (fileWatcher != null) { - fileWatcher.close(); + if (this.fileWatcher != null) { + this.fileWatcher.close(); } - if (messagingService != null) { + if (this.messagingService != null) { getLog().info("Closing messaging service..."); - messagingService.close(); + this.messagingService.close(); } ApiRegistrationUtil.unregisterProvider(); getLog().info("Shutting down internal scheduler..."); - scheduler.shutdown(); + this.scheduler.shutdown(); getLog().info("Goodbye!"); } @Override public void onPostUpdate() { - for (LPSubjectCollection collection : service.getLoadedCollections().values()) { + for (LPSubjectCollection collection : this.service.getLoadedCollections().values()) { if (collection instanceof PersistedCollection) { ((PersistedCollection) collection).loadAll(); } } - service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); } private Path resolveConfig(String file) { - Path path = configDirectory.resolve(file); + Path path = this.configDirectory.resolve(file); if (!Files.exists(path)) { try { - Files.createDirectories(configDirectory); + Files.createDirectories(this.configDirectory); try (InputStream is = getClass().getClassLoader().getResourceAsStream(file)) { Files.copy(is, path); } @@ -371,16 +368,17 @@ public class LPSpongePlugin implements LuckPermsPlugin { @Override public Optional getMessagingService() { - return Optional.ofNullable(messagingService); + return Optional.ofNullable(this.messagingService); } + @Override public Optional getFileWatcher() { - return Optional.ofNullable(fileWatcher); + return Optional.ofNullable(this.fileWatcher); } @Override public File getDataDirectory() { - File serverRoot = configDirectory.toFile().getParentFile().getParentFile(); + File serverRoot = this.configDirectory.toFile().getParentFile().getParentFile(); File dataDirectory = new File(serverRoot, "luckperms"); dataDirectory.mkdirs(); return dataDirectory; @@ -388,7 +386,7 @@ public class LPSpongePlugin implements LuckPermsPlugin { @Override public File getConfigDirectory() { - return configDirectory.toFile(); + return this.configDirectory.toFile(); } @Override @@ -398,20 +396,20 @@ public class LPSpongePlugin implements LuckPermsPlugin { @Override public Player getPlayer(User user) { - if (!game.isServerAvailable()) { + if (!this.game.isServerAvailable()) { return null; } - return game.getServer().getPlayer(uuidCache.getExternalUUID(user.getUuid())).orElse(null); + return this.game.getServer().getPlayer(this.uuidCache.getExternalUUID(user.getUuid())).orElse(null); } @Override public Optional lookupUuid(String username) { - if (!game.isServerAvailable()) { + if (!this.game.isServerAvailable()) { return Optional.empty(); } - CompletableFuture fut = game.getServer().getGameProfileManager().get(username); + CompletableFuture fut = this.game.getServer().getGameProfileManager().get(username); try { return Optional.of(fut.get().getUniqueId()); } catch (InterruptedException | ExecutionException e) { @@ -426,7 +424,7 @@ public class LPSpongePlugin implements LuckPermsPlugin { if (player == null) { return null; } - return contextManager.getApplicableContexts(player); + return this.contextManager.getApplicableContexts(player); } @Override @@ -454,47 +452,47 @@ public class LPSpongePlugin implements LuckPermsPlugin { @Override public int getPlayerCount() { - return game.isServerAvailable() ? game.getServer().getOnlinePlayers().size() : 0; + return this.game.isServerAvailable() ? this.game.getServer().getOnlinePlayers().size() : 0; } @Override public Stream getPlayerList() { - return game.isServerAvailable() ? game.getServer().getOnlinePlayers().stream().map(Player::getName) : Stream.empty(); + return this.game.isServerAvailable() ? this.game.getServer().getOnlinePlayers().stream().map(Player::getName) : Stream.empty(); } @Override public Stream getOnlinePlayers() { - return game.isServerAvailable() ? game.getServer().getOnlinePlayers().stream().map(Player::getUniqueId) : Stream.empty(); + return this.game.isServerAvailable() ? this.game.getServer().getOnlinePlayers().stream().map(Player::getUniqueId) : Stream.empty(); } @Override public boolean isPlayerOnline(UUID external) { - return game.isServerAvailable() ? game.getServer().getPlayer(external).map(Player::isOnline).orElse(false) : false; + return this.game.isServerAvailable() ? this.game.getServer().getPlayer(external).map(Player::isOnline).orElse(false) : false; } @Override public Stream getOnlineSenders() { - if (!game.isServerAvailable()) { + if (!this.game.isServerAvailable()) { return Stream.empty(); } return Stream.concat( Stream.of(getConsoleSender()), - game.getServer().getOnlinePlayers().stream().map(s -> getSenderFactory().wrap(s)) + this.game.getServer().getOnlinePlayers().stream().map(s -> getSenderFactory().wrap(s)) ); } @Override public Sender getConsoleSender() { - if (!game.isServerAvailable()) { + if (!this.game.isServerAvailable()) { return new DummySender(this, me.lucko.luckperms.common.commands.CommandManager.CONSOLE_UUID, me.lucko.luckperms.common.commands.CommandManager.CONSOLE_NAME) { @Override protected void consumeMessage(String s) { - logger.info(s); + LPSpongePlugin.this.logger.info(s); } }; } - return getSenderFactory().wrap(game.getServer().getConsole()); + return getSenderFactory().wrap(this.game.getServer().getConsole()); } @Override @@ -505,15 +503,148 @@ public class LPSpongePlugin implements LuckPermsPlugin { @Override public Map getExtraInfo() { Map map = new LinkedHashMap<>(); - map.put("SubjectCollection count", service.getLoadedCollections().size()); + map.put("SubjectCollection count", this.service.getLoadedCollections().size()); map.put("Subject count", - service.getLoadedCollections().values().stream() + this.service.getLoadedCollections().values().stream() .map(LPSubjectCollection::getLoadedSubjects) .mapToInt(AbstractCollection::size) .sum() ); - map.put("PermissionDescription count", service.getDescriptions().size()); + map.put("PermissionDescription count", this.service.getDescriptions().size()); return map; } + public Game getGame() { + return this.game; + } + + public Scheduler getSpongeScheduler() { + return this.spongeScheduler; + } + + public SpongeExecutorService getSyncExecutorService() { + return this.syncExecutorService; + } + + public SpongeExecutorService getAsyncExecutorService() { + return this.asyncExecutorService; + } + + @Override + public long getStartTime() { + return this.startTime; + } + + @Override + public SchedulerAdapter getScheduler() { + return this.scheduler; + } + + @Override + public SpongeCommandExecutor getCommandManager() { + return this.commandManager; + } + + @Override + public LuckPermsConfiguration getConfiguration() { + return this.configuration; + } + + @Override + public SpongeUserManager getUserManager() { + return this.userManager; + } + + @Override + public SpongeGroupManager getGroupManager() { + return this.groupManager; + } + + @Override + public TrackManager getTrackManager() { + return this.trackManager; + } + + @Override + public Storage getStorage() { + return this.storage; + } + + @Override + public UuidCache getUuidCache() { + return this.uuidCache; + } + + @Override + public LuckPermsApiProvider getApiProvider() { + return this.apiProvider; + } + + @Override + public EventFactory getEventFactory() { + return this.eventFactory; + } + + @Override + public me.lucko.luckperms.common.logging.Logger getLog() { + return this.log; + } + + public LuckPermsService getService() { + return this.service; + } + + @Override + public LocaleManager getLocaleManager() { + return this.localeManager; + } + + @Override + public DependencyManager getDependencyManager() { + return this.dependencyManager; + } + + @Override + public CachedStateManager getCachedStateManager() { + return this.cachedStateManager; + } + + @Override + public ContextManager getContextManager() { + return this.contextManager; + } + + @Override + public CalculatorFactory getCalculatorFactory() { + return this.calculatorFactory; + } + + @Override + public BufferedRequest getUpdateTaskBuffer() { + return this.updateTaskBuffer; + } + + @Override + public VerboseHandler getVerboseHandler() { + return this.verboseHandler; + } + + public SpongeSenderFactory getSenderFactory() { + return this.senderFactory; + } + + @Override + public PermissionVault getPermissionVault() { + return this.permissionVault; + } + + @Override + public LogDispatcher getLogDispatcher() { + return this.logDispatcher; + } + + @Override + public Set getUniqueConnections() { + return this.uniqueConnections; + } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeCommandExecutor.java b/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeCommandExecutor.java index 75f216dcd..40c7a026c 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeCommandExecutor.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeCommandExecutor.java @@ -43,6 +43,7 @@ import java.util.List; import java.util.ListIterator; import java.util.Optional; +import javax.annotation.Nonnull; import javax.annotation.Nullable; public class SpongeCommandExecutor extends CommandManager implements CommandCallable { @@ -56,40 +57,45 @@ public class SpongeCommandExecutor extends CommandManager implements CommandCall this.plugin = plugin; } + @Nonnull @Override - public CommandResult process(CommandSource source, String s) { - Sender lpSender = plugin.getSenderFactory().wrap(source); + public CommandResult process(@Nonnull CommandSource source, @Nonnull String s) { + Sender lpSender = this.plugin.getSenderFactory().wrap(source); List arguments = processSelectors(source, CommandManager.stripQuotes(ARGUMENT_SPLITTER.splitToList(s))); onCommand(lpSender, "lp", arguments); return CommandResult.success(); } + @Nonnull @Override - public List getSuggestions(CommandSource source, String s, @Nullable Location location) { - Sender lpSender = plugin.getSenderFactory().wrap(source); + public List getSuggestions(@Nonnull CommandSource source, @Nonnull String s, @Nullable Location location) { + Sender lpSender = this.plugin.getSenderFactory().wrap(source); List arguments = processSelectors(source, CommandManager.stripQuotes(TAB_COMPLETE_ARGUMENT_SPLITTER.splitToList(s))); return onTabComplete(lpSender, arguments); } @Override - public boolean testPermission(CommandSource source) { + public boolean testPermission(@Nonnull CommandSource source) { return true; // we run permission checks internally } + @Nonnull @Override - public Optional getShortDescription(CommandSource source) { + public Optional getShortDescription(@Nonnull CommandSource source) { return Optional.of(Text.of("Manage permissions")); } + @Nonnull @Override - public Optional getHelp(CommandSource source) { + public Optional getHelp(@Nonnull CommandSource source) { return Optional.of(Text.of("Run /luckperms to view usage.")); } + @Nonnull @Override - public Text getUsage(CommandSource source) { + public Text getUsage(@Nonnull CommandSource source) { return Text.of("/luckperms"); } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeConfigAdapter.java b/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeConfigAdapter.java index c8fd39385..59a8f1ebe 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeConfigAdapter.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeConfigAdapter.java @@ -57,10 +57,10 @@ public class SpongeConfigAdapter extends AbstractConfigurationAdapter implements @Override public void reload() { - ConfigurationLoader loader = HoconConfigurationLoader.builder().setPath(path).build(); + ConfigurationLoader loader = HoconConfigurationLoader.builder().setPath(this.path).build(); try { - root = loader.load(); + this.root = loader.load(); } catch (IOException e) { throw new RuntimeException(e); } @@ -68,7 +68,7 @@ public class SpongeConfigAdapter extends AbstractConfigurationAdapter implements private ConfigurationNode resolvePath(String path) { Iterable paths = Splitter.on('.').split(path); - ConfigurationNode node = root; + ConfigurationNode node = this.root; if (node == null) { throw new RuntimeException("Config is not loaded."); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeSchedulerAdapter.java b/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeSchedulerAdapter.java index cca3d85b7..7e03f6ab4 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeSchedulerAdapter.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/SpongeSchedulerAdapter.java @@ -43,48 +43,48 @@ public class SpongeSchedulerAdapter implements SchedulerAdapter { @Override public Executor async() { - return plugin.getAsyncExecutorService(); + return this.plugin.getAsyncExecutorService(); } @Override public Executor sync() { - return plugin.getSyncExecutorService(); + return this.plugin.getSyncExecutorService(); } @Override public void doAsync(Runnable runnable) { - plugin.getSpongeScheduler().createTaskBuilder().async().execute(runnable).submit(plugin); + this.plugin.getSpongeScheduler().createTaskBuilder().async().execute(runnable).submit(this.plugin); } @Override public void doSync(Runnable runnable) { - plugin.getSpongeScheduler().createTaskBuilder().execute(runnable).submit(plugin); + this.plugin.getSpongeScheduler().createTaskBuilder().execute(runnable).submit(this.plugin); } @Override public void asyncRepeating(Runnable runnable, long intervalTicks) { - Task task = plugin.getSpongeScheduler().createTaskBuilder().async().intervalTicks(intervalTicks).delayTicks(intervalTicks).execute(runnable).submit(plugin); - tasks.add(task); + Task task = this.plugin.getSpongeScheduler().createTaskBuilder().async().intervalTicks(intervalTicks).delayTicks(intervalTicks).execute(runnable).submit(this.plugin); + this.tasks.add(task); } @Override public void syncRepeating(Runnable runnable, long intervalTicks) { - Task task = plugin.getSpongeScheduler().createTaskBuilder().intervalTicks(intervalTicks).delayTicks(intervalTicks).execute(runnable).submit(plugin); - tasks.add(task); + Task task = this.plugin.getSpongeScheduler().createTaskBuilder().intervalTicks(intervalTicks).delayTicks(intervalTicks).execute(runnable).submit(this.plugin); + this.tasks.add(task); } @Override public void asyncLater(Runnable runnable, long delayTicks) { - plugin.getSpongeScheduler().createTaskBuilder().async().delayTicks(delayTicks).execute(runnable).submit(plugin); + this.plugin.getSpongeScheduler().createTaskBuilder().async().delayTicks(delayTicks).execute(runnable).submit(this.plugin); } @Override public void syncLater(Runnable runnable, long delayTicks) { - plugin.getSpongeScheduler().createTaskBuilder().delayTicks(delayTicks).execute(runnable).submit(plugin); + this.plugin.getSpongeScheduler().createTaskBuilder().delayTicks(delayTicks).execute(runnable).submit(this.plugin); } @Override public void shutdown() { - tasks.forEach(Task::cancel); + this.tasks.forEach(Task::cancel); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/calculators/SpongeCalculatorFactory.java b/sponge/src/main/java/me/lucko/luckperms/sponge/calculators/SpongeCalculatorFactory.java index e3cf37ad8..0da4860b4 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/calculators/SpongeCalculatorFactory.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/calculators/SpongeCalculatorFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.calculators; -import lombok.AllArgsConstructor; - import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.Contexts; @@ -46,47 +44,50 @@ import me.lucko.luckperms.sponge.processors.UserDefaultsProcessor; import java.util.List; -@AllArgsConstructor public class SpongeCalculatorFactory extends AbstractCalculatorFactory { private final LPSpongePlugin plugin; + public SpongeCalculatorFactory(LPSpongePlugin plugin) { + this.plugin = plugin; + } + @Override public PermissionCalculator build(Contexts contexts, PermissionCalculatorMetadata metadata) { ImmutableList.Builder processors = ImmutableList.builder(); processors.add(new MapProcessor()); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_IMPLICIT_WILDCARDS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_IMPLICIT_WILDCARDS)) { processors.add(new SpongeWildcardProcessor()); } - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) { processors.add(new RegexProcessor()); } - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) { processors.add(new WildcardProcessor()); } - if (plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_DEFAULT_SUBJECTS)) { + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_DEFAULT_SUBJECTS)) { if (metadata.getHolderType() == HolderType.USER) { - processors.add(new UserDefaultsProcessor(plugin.getService(), contexts.getContexts().makeImmutable())); + processors.add(new UserDefaultsProcessor(this.plugin.getService(), contexts.getContexts().makeImmutable())); } else if (metadata.getHolderType() == HolderType.GROUP) { - processors.add(new GroupDefaultsProcessor(plugin.getService(), contexts.getContexts().makeImmutable())); + processors.add(new GroupDefaultsProcessor(this.plugin.getService(), contexts.getContexts().makeImmutable())); } } - return registerCalculator(new PermissionCalculator(plugin, metadata, processors.build())); + return registerCalculator(new PermissionCalculator(this.plugin, metadata, processors.build())); } @Override public List getActiveProcessors() { ImmutableList.Builder ret = ImmutableList.builder(); ret.add("Map"); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_IMPLICIT_WILDCARDS)) ret.add("SpongeWildcard"); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) ret.add("Regex"); - if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) ret.add("Wildcard"); - if (plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_DEFAULT_SUBJECTS)) ret.add("Defaults"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_IMPLICIT_WILDCARDS)) ret.add("SpongeWildcard"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) ret.add("Regex"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) ret.add("Wildcard"); + if (this.plugin.getConfiguration().get(ConfigKeys.APPLY_SPONGE_DEFAULT_SUBJECTS)) ret.add("Defaults"); return ret.build(); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionClear.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionClear.java index 1690842d0..da9b3d075 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionClear.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionClear.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -47,7 +46,7 @@ public class OptionClear extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(0, args); if (contextSet.isEmpty()) { subjectData.clearOptions(); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionInfo.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionInfo.java index 9d66e6e7a..bde13b8fa 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionInfo.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionInfo.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.sponge.commands; import com.google.common.collect.ImmutableMap; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -50,7 +49,7 @@ public class OptionInfo extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(0, args); if (contextSet.isEmpty()) { CommandUtils.sendPluginMessage(sender, "&aShowing options matching contexts &bANY&a."); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionSet.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionSet.java index f3ce26daf..09237540c 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionSet.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionSet.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -47,7 +46,7 @@ public class OptionSet extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { String key = args.get(0); String value = args.get(1); ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(2, args); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionUnset.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionUnset.java index 149fc3889..17a316819 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionUnset.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/OptionUnset.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -47,7 +46,7 @@ public class OptionUnset extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { String key = args.get(0); ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(1, args); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentAdd.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentAdd.java index 470ade61a..df24b7fe1 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentAdd.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentAdd.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -52,7 +51,7 @@ public class ParentAdd extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { String collection = args.get(0); String name = args.get(1); ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(2, args); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentClear.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentClear.java index 2b50590a6..b743f6f4f 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentClear.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentClear.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -47,7 +46,7 @@ public class ParentClear extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(0, args); if (contextSet.isEmpty()) { subjectData.clearParents(); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentInfo.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentInfo.java index 8cbc0e6b7..2a757a9c1 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentInfo.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentInfo.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.sponge.commands; import com.google.common.collect.ImmutableList; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -51,7 +50,7 @@ public class ParentInfo extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(0, args); if (contextSet.isEmpty()) { CommandUtils.sendPluginMessage(sender, "&aShowing parents matching contexts &bANY&a."); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentRemove.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentRemove.java index 054ee05dc..9a8be3a86 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentRemove.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/ParentRemove.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -52,7 +51,7 @@ public class ParentRemove extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { String collection = args.get(0); String name = args.get(1); ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(2, args); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionClear.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionClear.java index 264c38b97..609ab71b9 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionClear.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionClear.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.commands; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -47,7 +46,7 @@ public class PermissionClear extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(0, args); if (contextSet.isEmpty()) { subjectData.clearPermissions(); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionInfo.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionInfo.java index 3acf875e6..caae58536 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionInfo.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/PermissionInfo.java @@ -28,7 +28,6 @@ package me.lucko.luckperms.sponge.commands; import com.google.common.collect.ImmutableMap; import me.lucko.luckperms.api.context.ImmutableContextSet; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -50,7 +49,7 @@ public class PermissionInfo extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, LPSubjectData subjectData, List args, String label) { ImmutableContextSet contextSet = ArgumentUtils.handleContextSponge(0, args); if (contextSet.isEmpty()) { CommandUtils.sendPluginMessage(sender, "&aShowing permissions matching contexts &bANY&a."); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeCommandUtils.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeCommandUtils.java index 5dbb76dbc..0cb025b1c 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeCommandUtils.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeCommandUtils.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.commands; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.common.commands.utils.ArgumentUtils; @@ -36,8 +34,7 @@ import me.lucko.luckperms.sponge.service.model.SubjectReference; import java.util.List; import java.util.Map; -@UtilityClass -public class SpongeCommandUtils { +public final class SpongeCommandUtils { public static Tristate parseTristate(int index, List args) throws ArgumentUtils.ArgumentException { String s = args.get(index).toLowerCase(); @@ -92,4 +89,6 @@ public class SpongeCommandUtils { return CommandUtils.contextSetToString(set); } + private SpongeCommandUtils() {} + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeMainCommand.java b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeMainCommand.java index 2ff2f4615..33f8d0731 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeMainCommand.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/commands/SpongeMainCommand.java @@ -63,7 +63,7 @@ public class SpongeMainCommand extends Command { LocaleManager locale = plugin.getLocaleManager(); - subCommands = ImmutableMap.>>builder() + this.subCommands = ImmutableMap.>>builder() .put("permission", ImmutableList.>builder() .add(new PermissionInfo(locale)) .add(new PermissionSet(locale)) @@ -90,7 +90,7 @@ public class SpongeMainCommand extends Command { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Void v, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Void v, List args, String label) { LuckPermsService service = this.plugin.getService(); if (args.size() < 1) { @@ -152,7 +152,7 @@ public class SpongeMainCommand extends Command { } String cmd = args.get(3); - Optional> o = subCommands.get(type).stream() + Optional> o = this.subCommands.get(type).stream() .filter(s -> s.getName().equalsIgnoreCase(cmd)) .findAny(); @@ -203,7 +203,7 @@ public class SpongeMainCommand extends Command { public void sendDetailedUsage(Sender sender, String label) { CommandUtils.sendPluginMessage(sender, "&b" + getName() + " Sub Commands: &7(" + String.format("/%s sponge [-transient]", label) + " ...)"); for (String s : Arrays.asList("Permission", "Parent", "Option")) { - List subs = subCommands.get(s.toLowerCase()).stream() + List subs = this.subCommands.get(s.toLowerCase()).stream() .filter(sub -> sub.isAuthorized(sender)) .collect(Collectors.toList()); @@ -222,7 +222,7 @@ public class SpongeMainCommand extends Command { } public List> getSubCommands() { - return subCommands.values().stream().flatMap(List::stream).collect(ImmutableCollectors.toList()); + return this.subCommands.values().stream().flatMap(List::stream).collect(ImmutableCollectors.toList()); } @Override diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/ProxiedContextCalculator.java b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/ProxiedContextCalculator.java index 36baeb5c8..a368b8882 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/ProxiedContextCalculator.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/ProxiedContextCalculator.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.contexts; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.context.ContextCalculator; import me.lucko.luckperms.api.context.MutableContextSet; import me.lucko.luckperms.sponge.service.context.DelegatingMutableContextSet; @@ -36,14 +34,20 @@ import org.spongepowered.api.service.permission.Subject; import java.util.Set; -@AllArgsConstructor +import javax.annotation.Nonnull; + public class ProxiedContextCalculator implements ContextCalculator { private final org.spongepowered.api.service.context.ContextCalculator delegate; + public ProxiedContextCalculator(org.spongepowered.api.service.context.ContextCalculator delegate) { + this.delegate = delegate; + } + + @Nonnull @Override - public MutableContextSet giveApplicableContext(Subject subject, MutableContextSet accumulator) { + public MutableContextSet giveApplicableContext(@Nonnull Subject subject, @Nonnull MutableContextSet accumulator) { Set contexts = new DelegatingMutableContextSet(accumulator); - delegate.accumulateContexts(subject, contexts); + this.delegate.accumulateContexts(subject, contexts); return accumulator; } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeContextManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeContextManager.java index e80282546..382de4256 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeContextManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/SpongeContextManager.java @@ -42,11 +42,11 @@ public class SpongeContextManager extends AbstractContextManager { public Contexts formContexts(Subject subject, ImmutableContextSet contextSet) { return new Contexts( contextSet, - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), - plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS), + this.plugin.getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS), true, - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), - plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS), + this.plugin.getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS), false ); } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java index 4109eee26..6c6e96230 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/contexts/WorldCalculator.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.contexts; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.api.Contexts; import me.lucko.luckperms.api.context.ContextCalculator; import me.lucko.luckperms.api.context.MutableContextSet; @@ -37,12 +35,18 @@ import org.spongepowered.api.command.CommandSource; import org.spongepowered.api.entity.living.player.Player; import org.spongepowered.api.service.permission.Subject; -@RequiredArgsConstructor +import javax.annotation.Nonnull; + public class WorldCalculator implements ContextCalculator { private final LuckPermsPlugin plugin; + public WorldCalculator(LuckPermsPlugin plugin) { + this.plugin = plugin; + } + + @Nonnull @Override - public MutableContextSet giveApplicableContext(Subject subject, MutableContextSet accumulator) { + public MutableContextSet giveApplicableContext(@Nonnull Subject subject, @Nonnull MutableContextSet accumulator) { CommandSource source = subject.getCommandSource().orElse(null); if (source == null || !(source instanceof Player)) { return accumulator; @@ -52,7 +56,7 @@ public class WorldCalculator implements ContextCalculator { String world = p.getWorld().getName().toLowerCase(); while (!accumulator.has(Contexts.WORLD_KEY, world)) { accumulator.add(Contexts.WORLD_KEY, world); - world = plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world).toLowerCase(); + world = this.plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world).toLowerCase(); } return accumulator; diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongeConnectionListener.java b/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongeConnectionListener.java index b4523aa15..4c9488573 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongeConnectionListener.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongeConnectionListener.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.listeners; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.config.ConfigKeys; import me.lucko.luckperms.common.locale.Message; import me.lucko.luckperms.common.model.User; @@ -47,13 +45,16 @@ import java.util.HashSet; import java.util.Set; import java.util.UUID; -@RequiredArgsConstructor public class SpongeConnectionListener { private final LPSpongePlugin plugin; private final Set deniedAsyncLogin = Collections.synchronizedSet(new HashSet<>()); private final Set deniedLogin = Collections.synchronizedSet(new HashSet<>()); + public SpongeConnectionListener(LPSpongePlugin plugin) { + this.plugin = plugin; + } + @Listener(order = Order.EARLY) @IsCancelled(Tristate.UNDEFINED) public void onClientAuth(ClientConnectionEvent.Auth e) { @@ -63,11 +64,11 @@ public class SpongeConnectionListener { final GameProfile p = e.getProfile(); final String username = p.getName().orElseThrow(() -> new RuntimeException("No username present for user " + p.getUniqueId())); - if (plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { - plugin.getLog().info("Processing auth event for " + p.getUniqueId() + " - " + p.getName()); + if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { + this.plugin.getLog().info("Processing auth event for " + p.getUniqueId() + " - " + p.getName()); } - plugin.getUniqueConnections().add(p.getUniqueId()); + this.plugin.getUniqueConnections().add(p.getUniqueId()); /* Actually process the login for the connection. We do this here to delay the login until the data is ready. @@ -79,18 +80,18 @@ public class SpongeConnectionListener { - creating a user instance in the UserManager for this connection. - setting up cached data. */ try { - User user = LoginHelper.loadUser(plugin, p.getUniqueId(), username, false); - plugin.getEventFactory().handleUserLoginProcess(p.getUniqueId(), username, user); + User user = LoginHelper.loadUser(this.plugin, p.getUniqueId(), username, false); + this.plugin.getEventFactory().handleUserLoginProcess(p.getUniqueId(), username, user); } catch (Exception ex) { - plugin.getLog().severe("Exception occured whilst loading data for " + p.getUniqueId() + " - " + p.getName()); + this.plugin.getLog().severe("Exception occured whilst loading data for " + p.getUniqueId() + " - " + p.getName()); ex.printStackTrace(); - deniedAsyncLogin.add(p.getUniqueId()); + this.deniedAsyncLogin.add(p.getUniqueId()); e.setCancelled(true); e.setMessageCancelled(false); //noinspection deprecation - e.setMessage(TextSerializers.LEGACY_FORMATTING_CODE.deserialize(Message.LOADING_ERROR.asString(plugin.getLocaleManager()))); + e.setMessage(TextSerializers.LEGACY_FORMATTING_CODE.deserialize(Message.LOADING_ERROR.asString(this.plugin.getLocaleManager()))); } } @@ -101,11 +102,11 @@ public class SpongeConnectionListener { If the connection was cancelled here, we need to do something to clean up the data that was loaded. */ // Check to see if this connection was denied at LOW. - if (deniedAsyncLogin.remove(e.getProfile().getUniqueId())) { + if (this.deniedAsyncLogin.remove(e.getProfile().getUniqueId())) { // This is a problem, as they were denied at low priority, but are now being allowed. if (e.isCancelled()) { - plugin.getLog().severe("Player connection was re-allowed for " + e.getProfile().getUniqueId()); + this.plugin.getLog().severe("Player connection was re-allowed for " + e.getProfile().getUniqueId()); e.setCancelled(true); } } @@ -120,21 +121,21 @@ public class SpongeConnectionListener { final GameProfile player = e.getProfile(); - if (plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { - plugin.getLog().info("Processing login event for " + player.getUniqueId() + " - " + player.getName()); + if (this.plugin.getConfiguration().get(ConfigKeys.DEBUG_LOGINS)) { + this.plugin.getLog().info("Processing login event for " + player.getUniqueId() + " - " + player.getName()); } - final User user = plugin.getUserManager().getIfLoaded(plugin.getUuidCache().getUUID(player.getUniqueId())); + final User user = this.plugin.getUserManager().getIfLoaded(this.plugin.getUuidCache().getUUID(player.getUniqueId())); /* User instance is null for whatever reason. Could be that it was unloaded between asyncpre and now. */ if (user == null) { - deniedLogin.add(player.getUniqueId()); + this.deniedLogin.add(player.getUniqueId()); - plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded. - denying login."); + this.plugin.getLog().warn("User " + player.getUniqueId() + " - " + player.getName() + " doesn't have data pre-loaded. - denying login."); e.setCancelled(true); e.setMessageCancelled(false); //noinspection deprecation - e.setMessage(TextSerializers.LEGACY_FORMATTING_CODE.deserialize(Message.LOADING_ERROR.asString(plugin.getLocaleManager()))); + e.setMessage(TextSerializers.LEGACY_FORMATTING_CODE.deserialize(Message.LOADING_ERROR.asString(this.plugin.getLocaleManager()))); } } @@ -145,10 +146,10 @@ public class SpongeConnectionListener { If the connection was cancelled here, we need to do something to clean up the data that was loaded. */ // Check to see if this connection was denied at LOW. Even if it was denied at LOW, their data will still be present. - if (deniedLogin.remove(e.getProfile().getUniqueId())) { + if (this.deniedLogin.remove(e.getProfile().getUniqueId())) { // This is a problem, as they were denied at low priority, but are now being allowed. if (!e.isCancelled()) { - plugin.getLog().severe("Player connection was re-allowed for " + e.getProfile().getUniqueId()); + this.plugin.getLog().severe("Player connection was re-allowed for " + e.getProfile().getUniqueId()); e.setCancelled(true); } } @@ -160,7 +161,7 @@ public class SpongeConnectionListener { on players when they disconnect. The instance gets cleared up on a housekeeping task after a period of inactivity. */ - final UuidCache cache = plugin.getUuidCache(); + final UuidCache cache = this.plugin.getUuidCache(); // Unload the user from memory when they disconnect cache.clearCache(e.getTargetEntity().getUniqueId()); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongePlatformListener.java b/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongePlatformListener.java index 2075556d2..15534a25f 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongePlatformListener.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/listeners/SpongePlatformListener.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.listeners; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.common.locale.Message; import me.lucko.luckperms.sponge.LPSpongePlugin; @@ -34,10 +32,13 @@ import org.spongepowered.api.command.CommandSource; import org.spongepowered.api.event.Listener; import org.spongepowered.api.event.command.SendCommandEvent; -@RequiredArgsConstructor public class SpongePlatformListener { private final LPSpongePlugin plugin; + public SpongePlatformListener(LPSpongePlugin plugin) { + this.plugin = plugin; + } + @Listener public void onSendCommand(SendCommandEvent e) { CommandSource source = e.getCause().first(CommandSource.class).orElse(null); @@ -45,7 +46,7 @@ public class SpongePlatformListener { final String name = e.getCommand().toLowerCase(); if (((name.equals("op") || name.equals("minecraft:op")) && source.hasPermission("minecraft.command.op")) || ((name.equals("deop") || name.equals("minecraft:deop")) && source.hasPermission("minecraft.command.deop"))) { - Message.OP_DISABLED_SPONGE.send(plugin.getSenderFactory().wrap(source)); + Message.OP_DISABLED_SPONGE.send(this.plugin.getSenderFactory().wrap(source)); } } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java index a48eaf8f4..706264e99 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeGroupManager.java @@ -25,11 +25,8 @@ package me.lucko.luckperms.sponge.managers; -import lombok.Getter; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -57,6 +54,7 @@ import org.spongepowered.api.service.permission.SubjectCollection; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.concurrent.CompletableFuture; @@ -65,7 +63,6 @@ import java.util.function.Predicate; public class SpongeGroupManager implements GroupManager, LPSubjectCollection { - @Getter private final LPSpongePlugin plugin; private SubjectCollection spongeProxy = null; @@ -104,7 +101,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { @Override public SpongeGroup apply(String name) { - return new SpongeGroup(name, plugin); + return new SpongeGroup(name, this.plugin); } /* ------------------------------------------ @@ -113,28 +110,28 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { @Override public Map getAll() { - return ImmutableMap.copyOf(objects.asMap()); + return ImmutableMap.copyOf(this.objects.asMap()); } @Override public SpongeGroup getOrMake(String id) { - return objects.get(id.toLowerCase()); + return this.objects.get(id.toLowerCase()); } @Override public SpongeGroup getIfLoaded(String id) { - return objects.getIfPresent(id.toLowerCase()); + return this.objects.getIfPresent(id.toLowerCase()); } @Override public boolean isLoaded(String id) { - return objects.asMap().containsKey(id.toLowerCase()); + return this.objects.asMap().containsKey(id.toLowerCase()); } @Override public void unload(String id) { if (id != null) { - objects.invalidate(id.toLowerCase()); + this.objects.invalidate(id.toLowerCase()); } } @@ -147,7 +144,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { @Override public void unloadAll() { - objects.invalidateAll(); + this.objects.invalidateAll(); } /* ------------------------------------------ @@ -156,16 +153,16 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { @Override public synchronized SubjectCollection sponge() { - if (spongeProxy == null) { - Preconditions.checkNotNull(plugin.getService(), "service"); - spongeProxy = ProxyFactory.toSponge(this); + if (this.spongeProxy == null) { + Objects.requireNonNull(this.plugin.getService(), "service"); + this.spongeProxy = ProxyFactory.toSponge(this); } - return spongeProxy; + return this.spongeProxy; } @Override public LuckPermsService getService() { - return plugin.getService(); + return this.plugin.getService(); } @Override @@ -186,12 +183,12 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { return fut; } - LPSubject present = subjectLoadingCache.getIfPresent(identifier.toLowerCase()); + LPSubject present = this.subjectLoadingCache.getIfPresent(identifier.toLowerCase()); if (present != null) { return CompletableFuture.completedFuture(present); } - return CompletableFuture.supplyAsync(() -> subjectLoadingCache.get(identifier.toLowerCase()), plugin.getScheduler().async()); + return CompletableFuture.supplyAsync(() -> this.subjectLoadingCache.get(identifier.toLowerCase()), this.plugin.getScheduler().async()); } @Override @@ -217,7 +214,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { } return ret.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override @@ -235,7 +232,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { return CompletableFuture.supplyAsync(() -> { ImmutableMap.Builder ret = ImmutableMap.builder(); - List> lookup = plugin.getStorage().getGroupsWithPermission(permission).join(); + List> lookup = this.plugin.getStorage().getGroupsWithPermission(permission).join(); for (HeldPermission holder : lookup) { if (holder.asNode().getFullContexts().equals(ImmutableContextSet.empty())) { ret.put(SubjectReferenceFactory.obtain(getService(), getIdentifier(), holder.getHolder()), holder.getValue()); @@ -243,7 +240,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { } return ret.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override @@ -251,7 +248,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { return CompletableFuture.supplyAsync(() -> { ImmutableMap.Builder ret = ImmutableMap.builder(); - List> lookup = plugin.getStorage().getGroupsWithPermission(permission).join(); + List> lookup = this.plugin.getStorage().getGroupsWithPermission(permission).join(); for (HeldPermission holder : lookup) { if (holder.asNode().getFullContexts().equals(contexts)) { ret.put(SubjectReferenceFactory.obtain(getService(), getIdentifier(), holder.getHolder()), holder.getValue()); @@ -259,12 +256,12 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { } return ret.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override public ImmutableMap getLoadedWithPermission(String permission) { - return objects.asMap().values().stream() + return this.objects.asMap().values().stream() .map(SpongeGroup::sponge) .map(sub -> Maps.immutableEntry(sub, sub.getPermissionValue(ImmutableContextSet.empty(), permission))) .filter(pair -> pair.getValue() != Tristate.UNDEFINED) @@ -273,7 +270,7 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { @Override public ImmutableMap getLoadedWithPermission(ImmutableContextSet contexts, String permission) { - return objects.asMap().values().stream() + return this.objects.asMap().values().stream() .map(SpongeGroup::sponge) .map(sub -> Maps.immutableEntry(sub, sub.getPermissionValue(contexts, permission))) .filter(pair -> pair.getValue() != Tristate.UNDEFINED) @@ -309,4 +306,9 @@ public class SpongeGroupManager implements GroupManager, LPSubjectCollection { return null; } + + public LPSpongePlugin getPlugin() { + return this.plugin; + } + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java index f9735f5e8..f71639334 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/managers/SpongeUserManager.java @@ -25,11 +25,8 @@ package me.lucko.luckperms.sponge.managers; -import lombok.Getter; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; @@ -57,6 +54,7 @@ import org.spongepowered.api.service.permission.SubjectCollection; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.UUID; @@ -66,7 +64,6 @@ import java.util.function.Predicate; public class SpongeUserManager implements UserManager, LPSubjectCollection { - @Getter private final LPSpongePlugin plugin; private SubjectCollection spongeProxy = null; @@ -109,8 +106,8 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public SpongeUser apply(UserIdentifier id) { return !id.getUsername().isPresent() ? - new SpongeUser(id.getUuid(), plugin) : - new SpongeUser(id.getUuid(), id.getUsername().get(), plugin); + new SpongeUser(id.getUuid(), this.plugin) : + new SpongeUser(id.getUuid(), id.getUsername().get(), this.plugin); } /* ------------------------------------------ @@ -119,12 +116,12 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public Map getAll() { - return ImmutableMap.copyOf(objects.asMap()); + return ImmutableMap.copyOf(this.objects.asMap()); } @Override public SpongeUser getOrMake(UserIdentifier id) { - SpongeUser ret = objects.get(id); + SpongeUser ret = this.objects.get(id); if (id.getUsername().isPresent()) { ret.setName(id.getUsername().get(), false); } @@ -133,18 +130,18 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public SpongeUser getIfLoaded(UserIdentifier id) { - return objects.getIfPresent(id); + return this.objects.getIfPresent(id); } @Override public boolean isLoaded(UserIdentifier id) { - return objects.asMap().containsKey(id); + return this.objects.asMap().containsKey(id); } @Override public void unload(UserIdentifier id) { if (id != null) { - objects.invalidate(id); + this.objects.invalidate(id); } } @@ -157,7 +154,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public void unloadAll() { - objects.invalidateAll(); + this.objects.invalidateAll(); } /* ------------------------------------------ @@ -182,7 +179,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public boolean giveDefaultIfNeeded(User user, boolean save) { - return GenericUserManager.giveDefaultIfNeeded(user, save, plugin); + return GenericUserManager.giveDefaultIfNeeded(user, save, this.plugin); } @Override @@ -199,10 +196,10 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public CompletableFuture updateAllUsers() { return CompletableFuture.runAsync( - () -> plugin.getOnlinePlayers() - .map(u -> plugin.getUuidCache().getUUID(u)) - .forEach(u -> plugin.getStorage().loadUser(u, null).join()), - plugin.getScheduler().async() + () -> this.plugin.getOnlinePlayers() + .map(u -> this.plugin.getUuidCache().getUUID(u)) + .forEach(u -> this.plugin.getStorage().loadUser(u, null).join()), + this.plugin.getScheduler().async() ); } @@ -212,16 +209,16 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public synchronized SubjectCollection sponge() { - if (spongeProxy == null) { - Preconditions.checkNotNull(plugin.getService(), "service"); - spongeProxy = ProxyFactory.toSponge(this); + if (this.spongeProxy == null) { + Objects.requireNonNull(this.plugin.getService(), "service"); + this.spongeProxy = ProxyFactory.toSponge(this); } - return spongeProxy; + return this.spongeProxy; } @Override public LuckPermsService getService() { - return plugin.getService(); + return this.plugin.getService(); } @Override @@ -253,12 +250,12 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { return fut; } - LPSubject present = subjectLoadingCache.getIfPresent(uuid); + LPSubject present = this.subjectLoadingCache.getIfPresent(uuid); if (present != null) { return CompletableFuture.completedFuture(present); } - return CompletableFuture.supplyAsync(() -> subjectLoadingCache.get(uuid), plugin.getScheduler().async()); + return CompletableFuture.supplyAsync(() -> this.subjectLoadingCache.get(uuid), this.plugin.getScheduler().async()); } @Override @@ -288,7 +285,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { } UUID finalUuid = uuid; - return plugin.getStorage().getUniqueUsers().thenApply(set -> set.contains(finalUuid)); + return this.plugin.getStorage().getUniqueUsers().thenApply(set -> set.contains(finalUuid)); } @Override @@ -307,7 +304,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { } return ret.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override @@ -321,10 +318,10 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { ImmutableSet.Builder ids = ImmutableSet.builder(); getAll().keySet().forEach(uuid -> ids.add(uuid.getUuid().toString())); - plugin.getStorage().getUniqueUsers().join().forEach(uuid -> ids.add(uuid.toString())); + this.plugin.getStorage().getUniqueUsers().join().forEach(uuid -> ids.add(uuid.toString())); return ids.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override @@ -332,7 +329,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { return CompletableFuture.supplyAsync(() -> { ImmutableMap.Builder ret = ImmutableMap.builder(); - List> lookup = plugin.getStorage().getUsersWithPermission(permission).join(); + List> lookup = this.plugin.getStorage().getUsersWithPermission(permission).join(); for (HeldPermission holder : lookup) { if (holder.asNode().getFullContexts().equals(ImmutableContextSet.empty())) { ret.put(SubjectReferenceFactory.obtain(getService(), getIdentifier(), holder.getHolder().toString()), holder.getValue()); @@ -340,7 +337,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { } return ret.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override @@ -348,7 +345,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { return CompletableFuture.supplyAsync(() -> { ImmutableMap.Builder ret = ImmutableMap.builder(); - List> lookup = plugin.getStorage().getUsersWithPermission(permission).join(); + List> lookup = this.plugin.getStorage().getUsersWithPermission(permission).join(); for (HeldPermission holder : lookup) { if (holder.asNode().getFullContexts().equals(contexts)) { ret.put(SubjectReferenceFactory.obtain(getService(), getIdentifier(), holder.getHolder().toString()), holder.getValue()); @@ -356,12 +353,12 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { } return ret.build(); - }, plugin.getScheduler().async()); + }, this.plugin.getScheduler().async()); } @Override public ImmutableMap getLoadedWithPermission(String permission) { - return objects.asMap().values().stream() + return this.objects.asMap().values().stream() .map(SpongeUser::sponge) .map(sub -> Maps.immutableEntry(sub, sub.getPermissionValue(ImmutableContextSet.empty(), permission))) .filter(pair -> pair.getValue() != Tristate.UNDEFINED) @@ -370,7 +367,7 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { @Override public ImmutableMap getLoadedWithPermission(ImmutableContextSet contexts, String permission) { - return objects.asMap().values().stream() + return this.objects.asMap().values().stream() .map(SpongeUser::sponge) .map(sub -> Maps.immutableEntry(sub, sub.getPermissionValue(contexts, permission))) .filter(pair -> pair.getValue() != Tristate.UNDEFINED) @@ -382,4 +379,8 @@ public class SpongeUserManager implements UserManager, LPSubjectCollection { return getService().getDefaultSubjects().loadSubject(getIdentifier()).join(); } + public LPSpongePlugin getPlugin() { + return this.plugin; + } + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/messaging/BungeeMessagingService.java b/sponge/src/main/java/me/lucko/luckperms/sponge/messaging/BungeeMessagingService.java index 9d7f234b6..0aff65a4e 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/messaging/BungeeMessagingService.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/messaging/BungeeMessagingService.java @@ -41,6 +41,8 @@ import org.spongepowered.api.network.RemoteConnection; import java.util.Collection; import java.util.concurrent.TimeUnit; +import javax.annotation.Nonnull; + /** * An implementation of {@link ExtendedMessagingService} using the plugin messaging channels. */ @@ -54,25 +56,25 @@ public class BungeeMessagingService extends AbstractMessagingService implements } public void init() { - channel = plugin.getGame().getChannelRegistrar().createRawChannel(plugin, CHANNEL); - channel.addListener(Platform.Type.SERVER, this); + this.channel = this.plugin.getGame().getChannelRegistrar().createRawChannel(this.plugin, CHANNEL); + this.channel.addListener(Platform.Type.SERVER, this); } @Override public void close() { - if (channel != null) { - plugin.getGame().getChannelRegistrar().unbindChannel(channel); + if (this.channel != null) { + this.plugin.getGame().getChannelRegistrar().unbindChannel(this.channel); } } @Override protected void sendMessage(String message) { - plugin.getSpongeScheduler().createTaskBuilder().interval(10, TimeUnit.SECONDS).execute(task -> { - if (!plugin.getGame().isServerAvailable()) { + this.plugin.getSpongeScheduler().createTaskBuilder().interval(10, TimeUnit.SECONDS).execute(task -> { + if (!this.plugin.getGame().isServerAvailable()) { return; } - Collection players = plugin.getGame().getServer().getOnlinePlayers(); + Collection players = this.plugin.getGame().getServer().getOnlinePlayers(); Player p = Iterables.getFirst(players, null); if (p == null) { return; @@ -81,11 +83,11 @@ public class BungeeMessagingService extends AbstractMessagingService implements this.channel.sendTo(p, buf -> buf.writeUTF(message)); task.cancel(); - }).submit(plugin); + }).submit(this.plugin); } @Override - public void handlePayload(ChannelBuf buf, RemoteConnection connection, Platform.Type type) { + public void handlePayload(@Nonnull ChannelBuf buf, @Nonnull RemoteConnection connection, @Nonnull Platform.Type type) { String msg = buf.readUTF(); onMessage(msg, null); } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionManager.java b/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionManager.java index 06ece8ca2..041013dc9 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionManager.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionManager.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.migration; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -63,7 +62,7 @@ public class MigrationPermissionManager extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("PermissionManager"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionsEx.java b/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionsEx.java index f39e78ebd..86a64ba75 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionsEx.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionsEx.java @@ -26,7 +26,6 @@ package me.lucko.luckperms.sponge.migration; import me.lucko.luckperms.api.event.cause.CreationCause; -import me.lucko.luckperms.common.commands.CommandException; import me.lucko.luckperms.common.commands.CommandPermission; import me.lucko.luckperms.common.commands.CommandResult; import me.lucko.luckperms.common.commands.abstraction.SubCommand; @@ -69,7 +68,7 @@ public class MigrationPermissionsEx extends SubCommand { } @Override - public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) throws CommandException { + public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List args, String label) { ProgressLogger log = new ProgressLogger("PermissionsEx"); log.addListener(plugin.getConsoleSender()); log.addListener(sender); diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/migration/SpongeMigrationUtils.java b/sponge/src/main/java/me/lucko/luckperms/sponge/migration/SpongeMigrationUtils.java index 6611e0cf0..c68cd5138 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/migration/SpongeMigrationUtils.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/migration/SpongeMigrationUtils.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.migration; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.api.context.ContextSet; import me.lucko.luckperms.common.commands.impl.migration.MigrationUtils; import me.lucko.luckperms.common.model.Group; @@ -44,8 +42,7 @@ import java.util.List; import java.util.Map; import java.util.Set; -@UtilityClass -public class SpongeMigrationUtils { +public final class SpongeMigrationUtils { public static void migrateSubject(Subject from, PermissionHolder to, int priority) { if (to.getType().isGroup()) { @@ -121,4 +118,6 @@ public class SpongeMigrationUtils { } } + private SpongeMigrationUtils() {} + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java b/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java index c7d2e4ac4..d4680fedd 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeGroup.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.model; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; @@ -64,14 +62,12 @@ public class SpongeGroup extends Group { return this.spongeData; } - public class GroupSubject implements LPSubject { + public static class GroupSubject implements LPSubject { private final SpongeGroup parent; private final LPSpongePlugin plugin; - @Getter private final LuckPermsSubjectData subjectData; - @Getter private final LuckPermsSubjectData transientSubjectData; private GroupSubject(LPSpongePlugin plugin, SpongeGroup parent) { @@ -83,12 +79,12 @@ public class SpongeGroup extends Group { @Override public String getIdentifier() { - return parent.getObjectName(); + return this.parent.getObjectName(); } @Override public Optional getFriendlyIdentifier() { - return parent.getDisplayName(); + return this.parent.getDisplayName(); } @Override @@ -98,7 +94,7 @@ public class SpongeGroup extends Group { @Override public LPSubjectCollection getParentCollection() { - return plugin.getService().getGroupSubjects(); + return this.plugin.getService().getGroupSubjects(); } @Override @@ -108,12 +104,22 @@ public class SpongeGroup extends Group { @Override public LuckPermsService getService() { - return plugin.getService(); + return this.plugin.getService(); + } + + @Override + public LuckPermsSubjectData getSubjectData() { + return this.subjectData; + } + + @Override + public LuckPermsSubjectData getTransientSubjectData() { + return this.transientSubjectData; } @Override public Tristate getPermissionValue(ImmutableContextSet contexts, String permission) { - return parent.getCachedData().getPermissionData(plugin.getContextManager().formContexts(contexts)).getPermissionValue(permission, CheckOrigin.PLATFORM_LOOKUP_CHECK); + return this.parent.getCachedData().getPermissionData(this.plugin.getContextManager().formContexts(contexts)).getPermissionValue(permission, CheckOrigin.PLATFORM_LOOKUP_CHECK); } @Override @@ -125,7 +131,7 @@ public class SpongeGroup extends Group { public ImmutableList getParents(ImmutableContextSet contexts) { ImmutableSet.Builder subjects = ImmutableSet.builder(); - for (Map.Entry entry : parent.getCachedData().getPermissionData(plugin.getContextManager().formContexts(contexts)).getImmutableBacking().entrySet()) { + for (Map.Entry entry : this.parent.getCachedData().getPermissionData(this.plugin.getContextManager().formContexts(contexts)).getImmutableBacking().entrySet()) { if (!entry.getValue()) { continue; } @@ -135,20 +141,20 @@ public class SpongeGroup extends Group { continue; } - if (plugin.getGroupManager().isLoaded(groupName)) { - subjects.add(plugin.getService().getGroupSubjects().loadSubject(groupName).join().toReference()); + if (this.plugin.getGroupManager().isLoaded(groupName)) { + subjects.add(this.plugin.getService().getGroupSubjects().loadSubject(groupName).join().toReference()); } } - subjects.addAll(plugin.getService().getGroupSubjects().getDefaults().getParents(contexts)); - subjects.addAll(plugin.getService().getDefaults().getParents(contexts)); + subjects.addAll(this.plugin.getService().getGroupSubjects().getDefaults().getParents(contexts)); + subjects.addAll(this.plugin.getService().getDefaults().getParents(contexts)); return getService().sortSubjects(subjects.build()); } @Override public Optional getOption(ImmutableContextSet contexts, String s) { - MetaData data = parent.getCachedData().getMetaData(plugin.getContextManager().formContexts(contexts)); + MetaData data = this.parent.getCachedData().getMetaData(this.plugin.getContextManager().formContexts(contexts)); if (s.equalsIgnoreCase(NodeFactory.PREFIX_KEY)) { if (data.getPrefix() != null) { return Optional.of(data.getPrefix()); @@ -166,23 +172,23 @@ public class SpongeGroup extends Group { return Optional.of(val); } - Optional v = plugin.getService().getGroupSubjects().getDefaults().getOption(contexts, s); + Optional v = this.plugin.getService().getGroupSubjects().getDefaults().getOption(contexts, s); if (v.isPresent()) { return v; } - return plugin.getService().getDefaults().getOption(contexts, s); + return this.plugin.getService().getDefaults().getOption(contexts, s); } @Override public ImmutableContextSet getActiveContextSet() { - return plugin.getContextManager().getApplicableContext(this.sponge()); + return this.plugin.getContextManager().getApplicableContext(this.sponge()); } @Override public void invalidateCaches(CacheLevel cacheLevel) { // invalidate for all changes - parent.getCachedData().invalidateCaches(); + this.parent.getCachedData().invalidateCaches(); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeUser.java b/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeUser.java index 0a2f139d7..dcd4cf526 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeUser.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/model/SpongeUser.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.model; -import lombok.Getter; - import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; @@ -76,10 +74,8 @@ public class SpongeUser extends User { private final SpongeUser parent; private final LPSpongePlugin plugin; - @Getter private final LuckPermsSubjectData subjectData; - @Getter private final LuckPermsSubjectData transientSubjectData; private UserSubject(LPSpongePlugin plugin, SpongeUser parent) { @@ -91,23 +87,23 @@ public class SpongeUser extends User { @Override public String getIdentifier() { - return plugin.getUuidCache().getExternalUUID(parent.getUuid()).toString(); + return this.plugin.getUuidCache().getExternalUUID(this.parent.getUuid()).toString(); } @Override public Optional getFriendlyIdentifier() { - return parent.getName(); + return this.parent.getName(); } @Override public Optional getCommandSource() { - final UUID uuid = plugin.getUuidCache().getExternalUUID(parent.getUuid()); + final UUID uuid = this.plugin.getUuidCache().getExternalUUID(this.parent.getUuid()); return Sponge.getServer().getPlayer(uuid).map(Function.identity()); } @Override public LPSubjectCollection getParentCollection() { - return plugin.getService().getUserSubjects(); + return this.plugin.getService().getUserSubjects(); } @Override @@ -117,12 +113,22 @@ public class SpongeUser extends User { @Override public LuckPermsService getService() { - return plugin.getService(); + return this.plugin.getService(); + } + + @Override + public LuckPermsSubjectData getSubjectData() { + return this.subjectData; + } + + @Override + public LuckPermsSubjectData getTransientSubjectData() { + return this.transientSubjectData; } @Override public Tristate getPermissionValue(ImmutableContextSet contexts, String permission) { - return parent.getCachedData().getPermissionData(plugin.getContextManager().formContexts(contexts)).getPermissionValue(permission, CheckOrigin.PLATFORM_LOOKUP_CHECK); + return this.parent.getCachedData().getPermissionData(this.plugin.getContextManager().formContexts(contexts)).getPermissionValue(permission, CheckOrigin.PLATFORM_LOOKUP_CHECK); } @Override @@ -134,7 +140,7 @@ public class SpongeUser extends User { public ImmutableList getParents(ImmutableContextSet contexts) { ImmutableSet.Builder subjects = ImmutableSet.builder(); - for (Map.Entry entry : parent.getCachedData().getPermissionData(plugin.getContextManager().formContexts(contexts)).getImmutableBacking().entrySet()) { + for (Map.Entry entry : this.parent.getCachedData().getPermissionData(this.plugin.getContextManager().formContexts(contexts)).getImmutableBacking().entrySet()) { if (!entry.getValue()) { continue; } @@ -144,20 +150,20 @@ public class SpongeUser extends User { continue; } - if (plugin.getGroupManager().isLoaded(groupName)) { - subjects.add(plugin.getService().getGroupSubjects().loadSubject(groupName).join().toReference()); + if (this.plugin.getGroupManager().isLoaded(groupName)) { + subjects.add(this.plugin.getService().getGroupSubjects().loadSubject(groupName).join().toReference()); } } - subjects.addAll(plugin.getService().getUserSubjects().getDefaults().getParents(contexts)); - subjects.addAll(plugin.getService().getDefaults().getParents(contexts)); + subjects.addAll(this.plugin.getService().getUserSubjects().getDefaults().getParents(contexts)); + subjects.addAll(this.plugin.getService().getDefaults().getParents(contexts)); return getService().sortSubjects(subjects.build()); } @Override public Optional getOption(ImmutableContextSet contexts, String s) { - MetaData data = parent.getCachedData().getMetaData(plugin.getContextManager().formContexts(contexts)); + MetaData data = this.parent.getCachedData().getMetaData(this.plugin.getContextManager().formContexts(contexts)); if (s.equalsIgnoreCase(NodeFactory.PREFIX_KEY)) { if (data.getPrefix() != null) { return Optional.of(data.getPrefix()); @@ -175,23 +181,23 @@ public class SpongeUser extends User { return Optional.of(val); } - Optional v = plugin.getService().getUserSubjects().getDefaults().getOption(contexts, s); + Optional v = this.plugin.getService().getUserSubjects().getDefaults().getOption(contexts, s); if (v.isPresent()) { return v; } - return plugin.getService().getDefaults().getOption(contexts, s); + return this.plugin.getService().getDefaults().getOption(contexts, s); } @Override public ImmutableContextSet getActiveContextSet() { - return plugin.getContextManager().getApplicableContext(this.sponge()); + return this.plugin.getContextManager().getApplicableContext(this.sponge()); } @Override public void invalidateCaches(CacheLevel cacheLevel) { // invalidate for all changes - parent.getCachedData().invalidateCaches(); + this.parent.getCachedData().invalidateCaches(); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/GroupDefaultsProcessor.java b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/GroupDefaultsProcessor.java index 5d5ee5f0c..820a83641 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/GroupDefaultsProcessor.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/GroupDefaultsProcessor.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.processors; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.common.processors.PermissionProcessor; @@ -34,19 +32,23 @@ import me.lucko.luckperms.sponge.service.LuckPermsService; import java.util.Map; -@AllArgsConstructor public class GroupDefaultsProcessor implements PermissionProcessor { private final LuckPermsService service; private final ImmutableContextSet contexts; + public GroupDefaultsProcessor(LuckPermsService service, ImmutableContextSet contexts) { + this.service = service; + this.contexts = contexts; + } + @Override public Tristate hasPermission(String permission) { - Tristate t = service.getGroupSubjects().getDefaults().getPermissionValue(contexts, permission); + Tristate t = this.service.getGroupSubjects().getDefaults().getPermissionValue(this.contexts, permission); if (t != Tristate.UNDEFINED) { return t; } - t = service.getDefaults().getPermissionValue(contexts, permission); + t = this.service.getDefaults().getPermissionValue(this.contexts, permission); if (t != Tristate.UNDEFINED) { return t; } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java index 8836a535d..33f1c6bbb 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/SpongeWildcardProcessor.java @@ -46,7 +46,7 @@ public class SpongeWildcardProcessor implements PermissionProcessor { node = node.substring(0, endIndex); if (!node.isEmpty()) { - Tristate t = Tristate.fromNullableBoolean(map.get(node)); + Tristate t = Tristate.fromNullableBoolean(this.map.get(node)); if (t != Tristate.UNDEFINED) { return t; } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/UserDefaultsProcessor.java b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/UserDefaultsProcessor.java index 8168876c6..1334e390f 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/processors/UserDefaultsProcessor.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/processors/UserDefaultsProcessor.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.processors; -import lombok.AllArgsConstructor; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.common.processors.PermissionProcessor; @@ -34,19 +32,23 @@ import me.lucko.luckperms.sponge.service.LuckPermsService; import java.util.Map; -@AllArgsConstructor public class UserDefaultsProcessor implements PermissionProcessor { private final LuckPermsService service; private final ImmutableContextSet contexts; + public UserDefaultsProcessor(LuckPermsService service, ImmutableContextSet contexts) { + this.service = service; + this.contexts = contexts; + } + @Override public Tristate hasPermission(String permission) { - Tristate t = service.getUserSubjects().getDefaults().getPermissionValue(contexts, permission); + Tristate t = this.service.getUserSubjects().getDefaults().getPermissionValue(this.contexts, permission); if (t != Tristate.UNDEFINED) { return t; } - t = service.getDefaults().getPermissionValue(contexts, permission); + t = this.service.getDefaults().getPermissionValue(this.contexts, permission); if (t != Tristate.UNDEFINED) { return t; } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsPermissionDescription.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsPermissionDescription.java index 579b8cc7f..2a4d49bdd 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsPermissionDescription.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsPermissionDescription.java @@ -25,11 +25,6 @@ package me.lucko.luckperms.sponge.service; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; import me.lucko.luckperms.sponge.service.model.LPPermissionService; import me.lucko.luckperms.sponge.service.model.LPSubject; @@ -41,54 +36,89 @@ import org.spongepowered.api.service.permission.PermissionDescription; import org.spongepowered.api.text.Text; import java.util.Map; +import java.util.Objects; import java.util.Optional; import java.util.concurrent.CompletableFuture; -@RequiredArgsConstructor -@EqualsAndHashCode(of = "id") -@ToString(of = {"id", "description", "owner"}) +import javax.annotation.Nullable; + public final class LuckPermsPermissionDescription implements LPPermissionDescription { - @Getter private final LPPermissionService service; - @Getter private final String id; - - private final Text description; - - private final PluginContainer owner; + @Nullable private final Text description; + @Nullable private final PluginContainer owner; private PermissionDescription spongeProxy = null; + public LuckPermsPermissionDescription(LPPermissionService service, String id, @Nullable Text description, @Nullable PluginContainer owner) { + this.service = service; + this.id = Objects.requireNonNull(id, "id"); + this.description = description; + this.owner = owner; + } + @Override public synchronized PermissionDescription sponge() { - if (spongeProxy == null) { - spongeProxy = ProxyFactory.toSponge(this); + if (this.spongeProxy == null) { + this.spongeProxy = ProxyFactory.toSponge(this); } - return spongeProxy; + return this.spongeProxy; + } + + @Override + public LPPermissionService getService() { + return this.service; + } + + @Override + public String getId() { + return this.id; } @Override public Optional getDescription() { - return Optional.ofNullable(description); + return Optional.ofNullable(this.description); } @Override public Optional getOwner() { - return Optional.ofNullable(owner); + return Optional.ofNullable(this.owner); } @SuppressWarnings("unchecked") @Override public CompletableFuture> findAssignedSubjects(String id) { - LPSubjectCollection collection = service.getCollection(id); + LPSubjectCollection collection = this.service.getCollection(id); return (CompletableFuture) collection.getAllWithPermission(this.id); } @Override public Map getAssignedSubjects(String id) { - LPSubjectCollection collection = service.getCollection(id); + LPSubjectCollection collection = this.service.getCollection(id); return collection.getLoadedWithPermission(this.id); } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof LuckPermsPermissionDescription)) return false; + final LuckPermsPermissionDescription other = (LuckPermsPermissionDescription) o; + return this.id.equals(other.id); + } + + @Override + public int hashCode() { + return this.id.hashCode(); + } + + @Override + public String toString() { + return "LuckPermsPermissionDescription(" + + "id=" + this.id + ", " + + "description=" + this.description + ", " + + "owner=" + this.owner + ")"; + } + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java index 81658e307..6a885abbb 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsService.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.sponge.service; -import lombok.AccessLevel; -import lombok.Getter; -import lombok.NonNull; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.collect.ImmutableList; @@ -62,6 +58,7 @@ import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; @@ -70,12 +67,10 @@ import java.util.function.Predicate; /** * LuckPerms implementation of the Sponge Permission Service */ -@Getter public class LuckPermsService implements LPPermissionService { private final LPSpongePlugin plugin; - @Getter(AccessLevel.NONE) private final PermissionService spongeProxy; private final SubjectReferenceFactory referenceFactory; @@ -85,7 +80,6 @@ public class LuckPermsService implements LPPermissionService { private final PersistedCollection defaultSubjects; private final Set descriptionSet; - @Getter(value = AccessLevel.NONE) private final LoadingCache collections = Caffeine.newBuilder() .build(s -> new PersistedCollection(this, s)); @@ -94,34 +88,63 @@ public class LuckPermsService implements LPPermissionService { this.referenceFactory = new SubjectReferenceFactory(this); this.spongeProxy = ProxyFactory.toSponge(this); - storage = new SubjectStorage(this, new File(plugin.getDataDirectory(), "sponge-data")); - new LegacyDataMigrator(plugin, new File(plugin.getDataDirectory(), "local"), storage).run(); + this.storage = new SubjectStorage(this, new File(plugin.getDataDirectory(), "sponge-data")); + new LegacyDataMigrator(plugin, new File(plugin.getDataDirectory(), "local"), this.storage).run(); - userSubjects = plugin.getUserManager(); - groupSubjects = plugin.getGroupManager(); - defaultSubjects = new PersistedCollection(this, "defaults"); - defaultSubjects.loadAll(); + this.userSubjects = plugin.getUserManager(); + this.groupSubjects = plugin.getGroupManager(); + this.defaultSubjects = new PersistedCollection(this, "defaults"); + this.defaultSubjects.loadAll(); - collections.put("user", userSubjects); - collections.put("group", groupSubjects); - collections.put("defaults", defaultSubjects); + this.collections.put("user", this.userSubjects); + this.collections.put("group", this.groupSubjects); + this.collections.put("defaults", this.defaultSubjects); - for (String collection : storage.getSavedCollections()) { - if (collections.asMap().containsKey(collection.toLowerCase())) { + for (String collection : this.storage.getSavedCollections()) { + if (this.collections.asMap().containsKey(collection.toLowerCase())) { continue; } PersistedCollection c = new PersistedCollection(this, collection.toLowerCase()); c.loadAll(); - collections.put(c.getIdentifier(), c); + this.collections.put(c.getIdentifier(), c); } - descriptionSet = ConcurrentHashMap.newKeySet(); + this.descriptionSet = ConcurrentHashMap.newKeySet(); } @Override public PermissionService sponge() { - return spongeProxy; + return this.spongeProxy; + } + + @Override + public LPSpongePlugin getPlugin() { + return this.plugin; + } + + @Override + public SubjectReferenceFactory getReferenceFactory() { + return this.referenceFactory; + } + + public SubjectStorage getStorage() { + return this.storage; + } + + @Override + public SpongeUserManager getUserSubjects() { + return this.userSubjects; + } + + @Override + public SpongeGroupManager getGroupSubjects() { + return this.groupSubjects; + } + + @Override + public PersistedCollection getDefaultSubjects() { + return this.defaultSubjects; } @Override @@ -136,24 +159,26 @@ public class LuckPermsService implements LPPermissionService { @Override public LPSubjectCollection getCollection(String s) { - return collections.get(s.toLowerCase()); + Objects.requireNonNull(s); + return this.collections.get(s.toLowerCase()); } @Override public ImmutableMap getLoadedCollections() { - return ImmutableMap.copyOf(collections.asMap()); + return ImmutableMap.copyOf(this.collections.asMap()); } @Override public LPPermissionDescription registerPermissionDescription(String id, Text description, PluginContainer owner) { LuckPermsPermissionDescription desc = new LuckPermsPermissionDescription(this, id, description, owner); - descriptionSet.add(desc); + this.descriptionSet.add(desc); return desc; } @Override - public Optional getDescription(@NonNull String s) { - for (LPPermissionDescription d : descriptionSet) { + public Optional getDescription(String s) { + Objects.requireNonNull(s); + for (LPPermissionDescription d : this.descriptionSet) { if (d.getId().equals(s)) { return Optional.of(d); } @@ -164,10 +189,10 @@ public class LuckPermsService implements LPPermissionService { @Override public ImmutableSet getDescriptions() { - Set descriptions = new HashSet<>(descriptionSet); + Set descriptions = new HashSet<>(this.descriptionSet); // collect known values from the permission vault - for (String knownPermission : plugin.getPermissionVault().getKnownPermissions()) { + for (String knownPermission : this.plugin.getPermissionVault().getKnownPermissions()) { LPPermissionDescription desc = new LuckPermsPermissionDescription(this, knownPermission, null, null); // don't override plugin defined values @@ -181,7 +206,8 @@ public class LuckPermsService implements LPPermissionService { @Override public void registerContextCalculator(org.spongepowered.api.service.context.ContextCalculator calculator) { - plugin.getContextManager().registerCalculator(new ProxiedContextCalculator(calculator)); + Objects.requireNonNull(calculator); + this.plugin.getContextManager().registerCalculator(new ProxiedContextCalculator(calculator)); } @Override @@ -204,8 +230,8 @@ public class LuckPermsService implements LPPermissionService { return 1; } - Group g1 = plugin.getGroupManager().getIfLoaded(o1.getSubjectIdentifier()); - Group g2 = plugin.getGroupManager().getIfLoaded(o2.getSubjectIdentifier()); + Group g1 = this.plugin.getGroupManager().getIfLoaded(o1.getSubjectIdentifier()); + Group g2 = this.plugin.getGroupManager().getIfLoaded(o2.getSubjectIdentifier()); boolean g1Null = g1 == null; boolean g2Null = g2 == null; @@ -226,14 +252,15 @@ public class LuckPermsService implements LPPermissionService { @Override public void invalidateAllCaches(LPSubject.CacheLevel cacheLevel) { - for (LPSubjectCollection collection : collections.asMap().values()) { + for (LPSubjectCollection collection : this.collections.asMap().values()) { for (LPSubject subject : collection.getLoadedSubjects()) { subject.invalidateCaches(cacheLevel); } } if (cacheLevel != LPSubject.CacheLevel.OPTION) { - plugin.getCalculatorFactory().invalidateAll(); + this.plugin.getCalculatorFactory().invalidateAll(); } } + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsSubjectData.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsSubjectData.java index 9c825a69e..0aed07441 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsSubjectData.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/LuckPermsSubjectData.java @@ -25,10 +25,6 @@ package me.lucko.luckperms.sponge.service; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.NonNull; - import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; @@ -52,27 +48,37 @@ import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.concurrent.CompletableFuture; import java.util.function.Consumer; import java.util.stream.Collectors; import java.util.stream.Stream; -@AllArgsConstructor public class LuckPermsSubjectData implements LPSubjectData { private final boolean enduring; private final LuckPermsService service; - @Getter private final PermissionHolder holder; - @Getter private final LPSubject parentSubject; + public LuckPermsSubjectData(boolean enduring, LuckPermsService service, PermissionHolder holder, LPSubject parentSubject) { + this.enduring = enduring; + this.service = service; + this.holder = holder; + this.parentSubject = parentSubject; + } + + @Override + public LPSubject getParentSubject() { + return this.parentSubject; + } + @Override public ImmutableMap> getAllPermissions() { Map> perms = new HashMap<>(); - for (Map.Entry> e : (enduring ? holder.getEnduringNodes() : holder.getTransientNodes()).asMap().entrySet()) { + for (Map.Entry> e : (this.enduring ? this.holder.getEnduringNodes() : this.holder.getTransientNodes()).asMap().entrySet()) { ImmutableMap.Builder results = ImmutableMap.builder(); for (Node n : e.getValue()) { results.put(n.getPermission(), n.getValuePrimitive()); @@ -88,66 +94,72 @@ public class LuckPermsSubjectData implements LPSubjectData { } @Override - public CompletableFuture setPermission(@NonNull ImmutableContextSet contexts, @NonNull String permission, @NonNull Tristate tristate) { + public CompletableFuture setPermission(ImmutableContextSet contexts, String permission, Tristate tristate) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(permission, "permission"); + Objects.requireNonNull(tristate, "tristate"); + if (tristate == Tristate.UNDEFINED) { // Unset Node node = NodeFactory.builder(permission).withExtraContext(contexts).build(); - if (enduring) { - holder.unsetPermission(node); + if (this.enduring) { + this.holder.unsetPermission(node); } else { - holder.unsetTransientPermission(node); + this.holder.unsetTransientPermission(node); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } Node node = NodeFactory.builder(permission).setValue(tristate.asBoolean()).withExtraContext(contexts).build(); // Workaround: unset the inverse, to allow false -> true, true -> false overrides. - if (enduring) { - holder.unsetPermission(node); + if (this.enduring) { + this.holder.unsetPermission(node); } else { - holder.unsetTransientPermission(node); + this.holder.unsetTransientPermission(node); } - if (enduring) { - holder.setPermission(node); + if (this.enduring) { + this.holder.setPermission(node); } else { - holder.setTransientPermission(node); + this.holder.setTransientPermission(node); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override public CompletableFuture clearPermissions() { boolean ret; - if (enduring) { - ret = holder.clearNodes(); + if (this.enduring) { + ret = this.holder.clearNodes(); } else { - ret = holder.clearTransientNodes(); + ret = this.holder.clearTransientNodes(); } if (!ret) { return CompletableFuture.completedFuture(false); } - if (holder.getType().isUser()) { - service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) holder), false); + if (this.holder.getType().isUser()) { + this.service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) this.holder), false); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override - public CompletableFuture clearPermissions(@NonNull ImmutableContextSet set) { + public CompletableFuture clearPermissions(ImmutableContextSet contexts) { + Objects.requireNonNull(contexts, "contexts"); + boolean ret; - if (enduring) { - ret = holder.clearNodes(set); + if (this.enduring) { + ret = this.holder.clearNodes(contexts); } else { List toRemove = streamNodes(false) - .filter(n -> n.getFullContexts().equals(set)) + .filter(n -> n.getFullContexts().equals(contexts)) .collect(Collectors.toList()); toRemove.forEach(makeUnsetConsumer(false)); @@ -158,22 +170,22 @@ public class LuckPermsSubjectData implements LPSubjectData { return CompletableFuture.completedFuture(false); } - if (holder.getType().isUser()) { - service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) holder), false); + if (this.holder.getType().isUser()) { + this.service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) this.holder), false); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override public ImmutableMap> getAllParents() { Map> parents = new HashMap<>(); - for (Map.Entry> e : (enduring ? holder.getEnduringNodes() : holder.getTransientNodes()).asMap().entrySet()) { + for (Map.Entry> e : (this.enduring ? this.holder.getEnduringNodes() : this.holder.getTransientNodes()).asMap().entrySet()) { ImmutableList.Builder results = ImmutableList.builder(); for (Node n : e.getValue()) { if (n.isGroupNode()) { - results.add(service.getGroupSubjects().loadSubject(n.getGroupName()).join().toReference()); + results.add(this.service.getGroupSubjects().loadSubject(n.getGroupName()).join().toReference()); } } parents.put(e.getKey(), results); @@ -187,17 +199,20 @@ public class LuckPermsSubjectData implements LPSubjectData { } @Override - public CompletableFuture addParent(@NonNull ImmutableContextSet contexts, @NonNull SubjectReference subject) { + public CompletableFuture addParent(ImmutableContextSet contexts, SubjectReference subject) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(subject, "subject"); + if (subject.getCollectionIdentifier().equals(PermissionService.SUBJECTS_GROUP)) { return subject.resolveLp().thenCompose(sub -> { DataMutateResult result; - if (enduring) { - result = holder.setPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) + if (this.enduring) { + result = this.holder.setPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) .withExtraContext(contexts) .build()); } else { - result = holder.setTransientPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) + result = this.holder.setTransientPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) .withExtraContext(contexts) .build()); } @@ -206,24 +221,27 @@ public class LuckPermsSubjectData implements LPSubjectData { return CompletableFuture.completedFuture(false); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); }); } return CompletableFuture.completedFuture(false); } @Override - public CompletableFuture removeParent(@NonNull ImmutableContextSet contexts, @NonNull SubjectReference subject) { + public CompletableFuture removeParent(ImmutableContextSet contexts, SubjectReference subject) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(subject, "subject"); + if (subject.getCollectionIdentifier().equals(PermissionService.SUBJECTS_GROUP)) { subject.resolveLp().thenCompose(sub -> { DataMutateResult result; - if (enduring) { - result = holder.unsetPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) + if (this.enduring) { + result = this.holder.unsetPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) .withExtraContext(contexts) .build()); } else { - result = holder.unsetTransientPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) + result = this.holder.unsetTransientPermission(NodeFactory.buildGroupNode(sub.getIdentifier()) .withExtraContext(contexts) .build()); } @@ -232,7 +250,7 @@ public class LuckPermsSubjectData implements LPSubjectData { return CompletableFuture.completedFuture(false); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); }); } return CompletableFuture.completedFuture(false); @@ -241,8 +259,8 @@ public class LuckPermsSubjectData implements LPSubjectData { @Override public CompletableFuture clearParents() { boolean ret; - if (enduring) { - ret = holder.clearParents(true); + if (this.enduring) { + ret = this.holder.clearParents(true); } else { List toRemove = streamNodes(false) .filter(Node::isGroupNode) @@ -251,8 +269,8 @@ public class LuckPermsSubjectData implements LPSubjectData { toRemove.forEach(makeUnsetConsumer(false)); ret = !toRemove.isEmpty(); - if (ret && holder.getType().isUser()) { - service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) holder), false); + if (ret && this.holder.getType().isUser()) { + this.service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) this.holder), false); } } @@ -260,25 +278,27 @@ public class LuckPermsSubjectData implements LPSubjectData { return CompletableFuture.completedFuture(false); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override - public CompletableFuture clearParents(@NonNull ImmutableContextSet set) { + public CompletableFuture clearParents(ImmutableContextSet contexts) { + Objects.requireNonNull(contexts, "contexts"); + boolean ret; - if (enduring) { - ret = holder.clearParents(set, true); + if (this.enduring) { + ret = this.holder.clearParents(contexts, true); } else { List toRemove = streamNodes(false) .filter(Node::isGroupNode) - .filter(n -> n.getFullContexts().equals(set)) + .filter(n -> n.getFullContexts().equals(contexts)) .collect(Collectors.toList()); toRemove.forEach(makeUnsetConsumer(false)); ret = !toRemove.isEmpty(); - if (ret && holder.getType().isUser()) { - service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) holder), false); + if (ret && this.holder.getType().isUser()) { + this.service.getPlugin().getUserManager().giveDefaultIfNeeded(((User) this.holder), false); } } @@ -286,7 +306,7 @@ public class LuckPermsSubjectData implements LPSubjectData { return CompletableFuture.completedFuture(false); } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override @@ -295,7 +315,7 @@ public class LuckPermsSubjectData implements LPSubjectData { Map minPrefixPriority = new HashMap<>(); Map minSuffixPriority = new HashMap<>(); - for (Node n : enduring ? holder.getEnduringNodes().values() : holder.getTransientNodes().values()) { + for (Node n : this.enduring ? this.holder.getEnduringNodes().values() : this.holder.getTransientNodes().values()) { if (!n.getValuePrimitive()) continue; if (!n.isMeta() && !n.isPrefix() && !n.isSuffix()) continue; @@ -339,51 +359,58 @@ public class LuckPermsSubjectData implements LPSubjectData { } @Override - public CompletableFuture setOption(@NonNull ImmutableContextSet context, @NonNull String key, @NonNull String value) { + public CompletableFuture setOption(ImmutableContextSet contexts, String key, String value) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(key, "key"); + Objects.requireNonNull(value, "value"); + if (key.equalsIgnoreCase(NodeFactory.PREFIX_KEY) || key.equalsIgnoreCase(NodeFactory.SUFFIX_KEY)) { // special handling. ChatMetaType type = ChatMetaType.valueOf(key.toUpperCase()); // remove all prefixes/suffixes from the user - List toRemove = streamNodes(enduring) + List toRemove = streamNodes(this.enduring) .filter(type::matches) - .filter(n -> n.getFullContexts().equals(context)) + .filter(n -> n.getFullContexts().equals(contexts)) .collect(Collectors.toList()); - toRemove.forEach(makeUnsetConsumer(enduring)); + toRemove.forEach(makeUnsetConsumer(this.enduring)); - MetaAccumulator metaAccumulator = holder.accumulateMeta(null, null, service.getPlugin().getContextManager().formContexts(context)); + MetaAccumulator metaAccumulator = this.holder.accumulateMeta(null, null, this.service.getPlugin().getContextManager().formContexts(contexts)); int priority = metaAccumulator.getChatMeta(type).keySet().stream().mapToInt(e -> e).max().orElse(0); priority += 10; - if (enduring) { - holder.setPermission(NodeFactory.buildChatMetaNode(type, priority, value).withExtraContext(context).build()); + if (this.enduring) { + this.holder.setPermission(NodeFactory.buildChatMetaNode(type, priority, value).withExtraContext(contexts).build()); } else { - holder.setTransientPermission(NodeFactory.buildChatMetaNode(type, priority, value).withExtraContext(context).build()); + this.holder.setTransientPermission(NodeFactory.buildChatMetaNode(type, priority, value).withExtraContext(contexts).build()); } } else { // standard remove - List toRemove = streamNodes(enduring) + List toRemove = streamNodes(this.enduring) .filter(n -> n.isMeta() && n.getMeta().getKey().equals(key)) - .filter(n -> n.getFullContexts().equals(context)) + .filter(n -> n.getFullContexts().equals(contexts)) .collect(Collectors.toList()); - toRemove.forEach(makeUnsetConsumer(enduring)); + toRemove.forEach(makeUnsetConsumer(this.enduring)); - if (enduring) { - holder.setPermission(NodeFactory.buildMetaNode(key, value).withExtraContext(context).build()); + if (this.enduring) { + this.holder.setPermission(NodeFactory.buildMetaNode(key, value).withExtraContext(contexts).build()); } else { - holder.setTransientPermission(NodeFactory.buildMetaNode(key, value).withExtraContext(context).build()); + this.holder.setTransientPermission(NodeFactory.buildMetaNode(key, value).withExtraContext(contexts).build()); } } - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override - public CompletableFuture unsetOption(ImmutableContextSet set, String key) { - List toRemove = streamNodes(enduring) + public CompletableFuture unsetOption(ImmutableContextSet contexts, String key) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(key, "key"); + + List toRemove = streamNodes(this.enduring) .filter(n -> { if (key.equalsIgnoreCase(NodeFactory.PREFIX_KEY)) { return n.isPrefix(); @@ -393,82 +420,84 @@ public class LuckPermsSubjectData implements LPSubjectData { return n.isMeta() && n.getMeta().getKey().equals(key); } }) - .filter(n -> n.getFullContexts().equals(set)) + .filter(n -> n.getFullContexts().equals(contexts)) .collect(Collectors.toList()); - toRemove.forEach(makeUnsetConsumer(enduring)); + toRemove.forEach(makeUnsetConsumer(this.enduring)); - return objectSave(holder).thenApply(v -> true); + return objectSave(this.holder).thenApply(v -> true); } @Override - public CompletableFuture clearOptions(@NonNull ImmutableContextSet set) { - List toRemove = streamNodes(enduring) + public CompletableFuture clearOptions(ImmutableContextSet contexts) { + Objects.requireNonNull(contexts, "contexts"); + + List toRemove = streamNodes(this.enduring) .filter(n -> n.isMeta() || n.isPrefix() || n.isSuffix()) - .filter(n -> n.getFullContexts().equals(set)) + .filter(n -> n.getFullContexts().equals(contexts)) .collect(Collectors.toList()); - toRemove.forEach(makeUnsetConsumer(enduring)); + toRemove.forEach(makeUnsetConsumer(this.enduring)); - return objectSave(holder).thenApply(v -> !toRemove.isEmpty()); + return objectSave(this.holder).thenApply(v -> !toRemove.isEmpty()); } @Override public CompletableFuture clearOptions() { - List toRemove = streamNodes(enduring) + List toRemove = streamNodes(this.enduring) .filter(n -> n.isMeta() || n.isPrefix() || n.isSuffix()) .collect(Collectors.toList()); - toRemove.forEach(makeUnsetConsumer(enduring)); + toRemove.forEach(makeUnsetConsumer(this.enduring)); - return objectSave(holder).thenApply(v -> !toRemove.isEmpty()); + return objectSave(this.holder).thenApply(v -> !toRemove.isEmpty()); } private Stream streamNodes(boolean enduring) { - return (enduring ? holder.getEnduringNodes() : holder.getTransientNodes()).values().stream(); + return (enduring ? this.holder.getEnduringNodes() : this.holder.getTransientNodes()).values().stream(); } private Consumer makeUnsetConsumer(boolean enduring) { return n -> { if (enduring) { - holder.unsetPermission(n); + this.holder.unsetPermission(n); } else { - holder.unsetTransientPermission(n); + this.holder.unsetTransientPermission(n); } }; } private CompletableFuture objectSave(PermissionHolder t) { - if (!enduring) { + if (!this.enduring) { // don't bother saving to primary storage. just refresh if (t.getType().isUser()) { User user = ((User) t); return user.getRefreshBuffer().request(); } else { - return service.getPlugin().getUpdateTaskBuffer().request(); + return this.service.getPlugin().getUpdateTaskBuffer().request(); } } else { if (t.getType().isUser()) { User user = ((User) t); CompletableFuture fut = new CompletableFuture<>(); - service.getPlugin().getStorage().saveUser(user).whenCompleteAsync((v, ex) -> { + this.service.getPlugin().getStorage().saveUser(user).whenCompleteAsync((v, ex) -> { if (ex != null) { fut.complete(null); } user.getRefreshBuffer().request().thenAccept(fut::complete); - }, service.getPlugin().getScheduler().async()); + }, this.service.getPlugin().getScheduler().async()); return fut; } else { Group group = ((Group) t); CompletableFuture fut = new CompletableFuture<>(); - service.getPlugin().getStorage().saveGroup(group).whenCompleteAsync((v, ex) -> { + this.service.getPlugin().getStorage().saveGroup(group).whenCompleteAsync((v, ex) -> { if (ex != null) { fut.complete(null); } - service.getPlugin().getUpdateTaskBuffer().request().thenAccept(fut::complete); - }, service.getPlugin().getScheduler().async()); + this.service.getPlugin().getUpdateTaskBuffer().request().thenAccept(fut::complete); + }, this.service.getPlugin().getScheduler().async()); return fut; } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/ProxyFactory.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/ProxyFactory.java index d5c65600a..3c2b0831c 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/ProxyFactory.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/ProxyFactory.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service; -import lombok.experimental.UtilityClass; - import me.lucko.luckperms.sponge.service.model.LPPermissionDescription; import me.lucko.luckperms.sponge.service.model.LPPermissionService; import me.lucko.luckperms.sponge.service.model.LPSubject; @@ -40,8 +38,7 @@ import org.spongepowered.api.service.permission.SubjectCollection; /** * Provides proxy instances which implement the SpongeAPI using the LuckPerms model. */ -@UtilityClass -public class ProxyFactory { +public final class ProxyFactory { private static final boolean IS_API_7 = isApi7(); private static boolean isApi7() { try { @@ -77,4 +74,6 @@ public class ProxyFactory { new me.lucko.luckperms.sponge.service.proxy.api6.PermissionDescriptionProxy(luckPerms.getService(), luckPerms); } + private ProxyFactory() {} + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java index 0e4a3dc49..5978a5cae 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/calculated/CalculatedSubjectData.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.sponge.service.calculated; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import com.github.benmanes.caffeine.cache.CacheLoader; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; @@ -60,13 +57,13 @@ import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; +import javax.annotation.Nonnull; + /** * In-memory implementation of {@link LPSubjectData}. */ -@RequiredArgsConstructor public class CalculatedSubjectData implements LPSubjectData { - @Getter private final LPSubject parentSubject; private final LPPermissionService service; @@ -80,61 +77,72 @@ public class CalculatedSubjectData implements LPSubjectData { .expireAfterAccess(10, TimeUnit.MINUTES) .build(new CacheLoader() { @Override - public CalculatorHolder load(ImmutableContextSet contexts) { + public CalculatorHolder load(@Nonnull ImmutableContextSet contexts) { ImmutableList.Builder processors = ImmutableList.builder(); processors.add(new MapProcessor()); processors.add(new SpongeWildcardProcessor()); - CalculatorHolder holder = new CalculatorHolder(new PermissionCalculator(service.getPlugin(), PermissionCalculatorMetadata.of(HolderType.GROUP, calculatorDisplayName, contexts), processors.build())); - holder.setPermissions(flattenMap(getRelevantEntries(contexts, permissions))); + CalculatorHolder holder = new CalculatorHolder(new PermissionCalculator(CalculatedSubjectData.this.service.getPlugin(), PermissionCalculatorMetadata.of(HolderType.GROUP, CalculatedSubjectData.this.calculatorDisplayName, contexts), processors.build())); + holder.setPermissions(flattenMap(getRelevantEntries(contexts, CalculatedSubjectData.this.permissions))); return holder; } }); + public CalculatedSubjectData(LPSubject parentSubject, LPPermissionService service, String calculatorDisplayName) { + this.parentSubject = parentSubject; + this.service = service; + this.calculatorDisplayName = calculatorDisplayName; + } + + @Override + public LPSubject getParentSubject() { + return this.parentSubject; + } + public void cleanup() { - permissionCache.cleanUp(); + this.permissionCache.cleanUp(); } public void invalidateLookupCache() { - permissionCache.invalidateAll(); + this.permissionCache.invalidateAll(); } public Tristate getPermissionValue(ImmutableContextSet contexts, String permission) { - return permissionCache.get(contexts).getCalculator().getPermissionValue(permission, CheckOrigin.INTERNAL); + return this.permissionCache.get(contexts).getCalculator().getPermissionValue(permission, CheckOrigin.INTERNAL); } public void replacePermissions(Map> map) { - permissions.clear(); + this.permissions.clear(); for (Map.Entry> e : map.entrySet()) { - permissions.put(e.getKey(), new ConcurrentHashMap<>(e.getValue())); + this.permissions.put(e.getKey(), new ConcurrentHashMap<>(e.getValue())); } - permissionCache.invalidateAll(); - service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); + this.permissionCache.invalidateAll(); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); } public void replaceParents(Map> map) { - parents.clear(); + this.parents.clear(); for (Map.Entry> e : map.entrySet()) { Set set = ConcurrentHashMap.newKeySet(); set.addAll(e.getValue()); - parents.put(e.getKey(), set); + this.parents.put(e.getKey(), set); } - service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); } public void replaceOptions(Map> map) { - options.clear(); + this.options.clear(); for (Map.Entry> e : map.entrySet()) { - options.put(e.getKey(), new ConcurrentHashMap<>(e.getValue())); + this.options.put(e.getKey(), new ConcurrentHashMap<>(e.getValue())); } - service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); + this.service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); } @Override public ImmutableMap> getAllPermissions() { ImmutableMap.Builder> map = ImmutableMap.builder(); - for (Map.Entry> e : permissions.entrySet()) { + for (Map.Entry> e : this.permissions.entrySet()) { map.put(e.getKey(), ImmutableMap.copyOf(e.getValue())); } return map.build(); @@ -144,42 +152,42 @@ public class CalculatedSubjectData implements LPSubjectData { public CompletableFuture setPermission(ImmutableContextSet contexts, String permission, Tristate value) { boolean b; if (value == Tristate.UNDEFINED) { - Map perms = permissions.get(contexts); + Map perms = this.permissions.get(contexts); b = perms != null && perms.remove(permission.toLowerCase()) != null; } else { - Map perms = permissions.computeIfAbsent(contexts, c -> new ConcurrentHashMap<>()); + Map perms = this.permissions.computeIfAbsent(contexts, c -> new ConcurrentHashMap<>()); b = !Objects.equals(perms.put(permission.toLowerCase(), value.asBoolean()), value.asBoolean()); } if (b) { - permissionCache.invalidateAll(); - service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); + this.permissionCache.invalidateAll(); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); } return CompletableFuture.completedFuture(b); } @Override public CompletableFuture clearPermissions() { - if (permissions.isEmpty()) { + if (this.permissions.isEmpty()) { return CompletableFuture.completedFuture(false); } else { - permissions.clear(); - permissionCache.invalidateAll(); - service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); + this.permissions.clear(); + this.permissionCache.invalidateAll(); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); return CompletableFuture.completedFuture(true); } } @Override public CompletableFuture clearPermissions(ImmutableContextSet contexts) { - Map perms = permissions.get(contexts); + Map perms = this.permissions.get(contexts); if (perms == null) { return CompletableFuture.completedFuture(false); } - permissions.remove(contexts); + this.permissions.remove(contexts); if (!perms.isEmpty()) { - permissionCache.invalidateAll(); - service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); + this.permissionCache.invalidateAll(); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PERMISSION); return CompletableFuture.completedFuture(true); } return CompletableFuture.completedFuture(false); @@ -188,59 +196,59 @@ public class CalculatedSubjectData implements LPSubjectData { @Override public ImmutableMap> getAllParents() { ImmutableMap.Builder> map = ImmutableMap.builder(); - for (Map.Entry> e : parents.entrySet()) { - map.put(e.getKey(), service.sortSubjects(e.getValue())); + for (Map.Entry> e : this.parents.entrySet()) { + map.put(e.getKey(), this.service.sortSubjects(e.getValue())); } return map.build(); } @Override public CompletableFuture addParent(ImmutableContextSet contexts, SubjectReference parent) { - Set set = parents.computeIfAbsent(contexts, c -> ConcurrentHashMap.newKeySet()); + Set set = this.parents.computeIfAbsent(contexts, c -> ConcurrentHashMap.newKeySet()); boolean b = set.add(parent); if (b) { - service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); } return CompletableFuture.completedFuture(b); } @Override public CompletableFuture removeParent(ImmutableContextSet contexts, SubjectReference parent) { - Set set = parents.get(contexts); + Set set = this.parents.get(contexts); boolean b = set != null && set.remove(parent); if (b) { - service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); } return CompletableFuture.completedFuture(b); } @Override public CompletableFuture clearParents() { - if (parents.isEmpty()) { + if (this.parents.isEmpty()) { return CompletableFuture.completedFuture(false); } else { - parents.clear(); - service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); + this.parents.clear(); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); return CompletableFuture.completedFuture(true); } } @Override public CompletableFuture clearParents(ImmutableContextSet contexts) { - Set set = parents.get(contexts); + Set set = this.parents.get(contexts); if (set == null) { return CompletableFuture.completedFuture(false); } - parents.remove(contexts); - service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); + this.parents.remove(contexts); + this.service.invalidateAllCaches(LPSubject.CacheLevel.PARENT); return CompletableFuture.completedFuture(!set.isEmpty()); } @Override public ImmutableMap> getAllOptions() { ImmutableMap.Builder> map = ImmutableMap.builder(); - for (Map.Entry> e : options.entrySet()) { + for (Map.Entry> e : this.options.entrySet()) { map.put(e.getKey(), ImmutableMap.copyOf(e.getValue())); } return map.build(); @@ -251,7 +259,7 @@ public class CalculatedSubjectData implements LPSubjectData { Map options = this.options.computeIfAbsent(contexts, c -> new ConcurrentHashMap<>()); boolean b = !stringEquals(options.put(key.toLowerCase(), value), value); if (b) { - service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); + this.service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); } return CompletableFuture.completedFuture(b); } @@ -261,31 +269,31 @@ public class CalculatedSubjectData implements LPSubjectData { Map options = this.options.get(contexts); boolean b = options != null && options.remove(key.toLowerCase()) != null; if (b) { - service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); + this.service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); } return CompletableFuture.completedFuture(b); } @Override public CompletableFuture clearOptions() { - if (options.isEmpty()) { + if (this.options.isEmpty()) { return CompletableFuture.completedFuture(false); } else { - options.clear(); - service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); + this.options.clear(); + this.service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); return CompletableFuture.completedFuture(true); } } @Override public CompletableFuture clearOptions(ImmutableContextSet contexts) { - Map map = options.get(contexts); + Map map = this.options.get(contexts); if (map == null) { return CompletableFuture.completedFuture(false); } - options.remove(contexts); - service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); + this.options.remove(contexts); + this.service.invalidateAllCaches(LPSubject.CacheLevel.OPTION); return CompletableFuture.completedFuture(!map.isEmpty()); } @@ -321,23 +329,25 @@ public class CalculatedSubjectData implements LPSubjectData { private static class CalculatorHolder { - @Getter private final PermissionCalculator calculator; - @Getter private final Map permissions; public CalculatorHolder(PermissionCalculator calculator) { this.calculator = calculator; this.permissions = new ConcurrentHashMap<>(); - this.calculator.updateBacking(permissions); + this.calculator.updateBacking(this.permissions); } public void setPermissions(Map permissions) { this.permissions.clear(); this.permissions.putAll(permissions); - calculator.updateBacking(this.permissions); - calculator.invalidateCache(); + this.calculator.updateBacking(this.permissions); + this.calculator.invalidateCache(); + } + + public PermissionCalculator getCalculator() { + return this.calculator; } } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/LegacyDataMigrator.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/LegacyDataMigrator.java index e231331d9..e65495eb9 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/LegacyDataMigrator.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/LegacyDataMigrator.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.legacy; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.sponge.LPSpongePlugin; import me.lucko.luckperms.sponge.service.storage.SubjectStorage; @@ -37,22 +35,27 @@ import java.nio.charset.StandardCharsets; import java.nio.file.Files; @SuppressWarnings("deprecation") -@RequiredArgsConstructor public class LegacyDataMigrator implements Runnable { private final LPSpongePlugin plugin; private final File oldDirectory; private final SubjectStorage storage; + public LegacyDataMigrator(LPSpongePlugin plugin, File oldDirectory, SubjectStorage storage) { + this.plugin = plugin; + this.oldDirectory = oldDirectory; + this.storage = storage; + } + @Override public void run() { - if (!oldDirectory.exists() || !oldDirectory.isDirectory()) { + if (!this.oldDirectory.exists() || !this.oldDirectory.isDirectory()) { return; } - plugin.getLog().warn("Migrating old sponge data... Please wait."); + this.plugin.getLog().warn("Migrating old sponge data... Please wait."); - File[] collections = oldDirectory.listFiles(File::isDirectory); + File[] collections = this.oldDirectory.listFiles(File::isDirectory); if (collections == null) { return; } @@ -68,8 +71,8 @@ public class LegacyDataMigrator implements Runnable { String subjectName = subjectFile.getName().substring(0, subjectFile.getName().length() - ".json".length()); try (BufferedReader reader = Files.newBufferedReader(subjectFile.toPath(), StandardCharsets.UTF_8)) { - SubjectDataHolder holder = storage.getGson().fromJson(reader, SubjectDataHolder.class); - storage.saveToFile(holder.asSubjectModel(plugin.getService()), storage.resolveFile(collectionDir.getName(), subjectName)); + SubjectDataHolder holder = this.storage.getGson().fromJson(reader, SubjectDataHolder.class); + this.storage.saveToFile(holder.asSubjectModel(this.plugin.getService()), this.storage.resolveFile(collectionDir.getName(), subjectName)); } catch (IOException e) { e.printStackTrace(); } @@ -80,6 +83,6 @@ public class LegacyDataMigrator implements Runnable { collectionDir.delete(); } - oldDirectory.delete(); + this.oldDirectory.delete(); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/SubjectDataHolder.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/SubjectDataHolder.java index b15c668d1..401e3faf3 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/SubjectDataHolder.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/legacy/SubjectDataHolder.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.legacy; -import lombok.ToString; - import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.sponge.service.model.LPPermissionService; import me.lucko.luckperms.sponge.service.model.SubjectReferenceFactory; @@ -41,7 +39,6 @@ import java.util.stream.Collectors; * @see SubjectStorageModel */ @SuppressWarnings("DeprecatedIsStillUsed") -@ToString @Deprecated public class SubjectDataHolder { private Map, Map> permissions; @@ -54,17 +51,17 @@ public class SubjectDataHolder { public SubjectStorageModel asSubjectModel(LPPermissionService service) { return new SubjectStorageModel(service, - permissions.entrySet().stream() + this.permissions.entrySet().stream() .collect(Collectors.toMap( k -> ImmutableContextSet.fromMap(k.getKey()), Map.Entry::getValue )), - options.entrySet().stream() + this.options.entrySet().stream() .collect(Collectors.toMap( k -> ImmutableContextSet.fromMap(k.getKey()), Map.Entry::getValue )), - parents.entrySet().stream() + this.parents.entrySet().stream() .collect(Collectors.toMap( k -> ImmutableContextSet.fromMap(k.getKey()), v -> v.getValue().stream().map(s -> SubjectReferenceFactory.deserialize(service, s)).collect(Collectors.toList()) diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/OptionLookupKey.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/OptionLookupKey.java index 28f207ca3..1ea45eccc 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/OptionLookupKey.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/OptionLookupKey.java @@ -25,20 +25,50 @@ package me.lucko.luckperms.sponge.service.persisted; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.context.ImmutableContextSet; -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor(staticName = "of") public final class OptionLookupKey { + public static OptionLookupKey of(String key, ImmutableContextSet contexts) { + return new OptionLookupKey(key, contexts); + } + private final String key; private final ImmutableContextSet contexts; + private OptionLookupKey(String key, ImmutableContextSet contexts) { + this.key = key; + this.contexts = contexts; + } + + public String getKey() { + return this.key; + } + + public ImmutableContextSet getContexts() { + return this.contexts; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof OptionLookupKey)) return false; + final OptionLookupKey other = (OptionLookupKey) o; + + return this.getKey().equals(other.getKey()) && this.getContexts().equals(other.getContexts()); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.getKey().hashCode(); + result = result * PRIME + this.getContexts().hashCode(); + return result; + } + + @Override + public String toString() { + return "OptionLookupKey(key=" + this.getKey() + ", contexts=" + this.getContexts() + ")"; + } } \ No newline at end of file diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PermissionLookupKey.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PermissionLookupKey.java index 1eaab3e1b..bdbcb9ba0 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PermissionLookupKey.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PermissionLookupKey.java @@ -25,20 +25,50 @@ package me.lucko.luckperms.sponge.service.persisted; -import lombok.AllArgsConstructor; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.ToString; - import me.lucko.luckperms.api.context.ImmutableContextSet; -@Getter -@ToString -@EqualsAndHashCode -@AllArgsConstructor(staticName = "of") public final class PermissionLookupKey { + public static PermissionLookupKey of(String node, ImmutableContextSet contexts) { + return new PermissionLookupKey(node, contexts); + } + private final String node; private final ImmutableContextSet contexts; + private PermissionLookupKey(String node, ImmutableContextSet contexts) { + this.node = node; + this.contexts = contexts; + } + + public String getNode() { + return this.node; + } + + public ImmutableContextSet getContexts() { + return this.contexts; + } + + @Override + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof PermissionLookupKey)) return false; + final PermissionLookupKey other = (PermissionLookupKey) o; + + return this.getNode().equals(other.getNode()) && this.getContexts().equals(other.getContexts()); + } + + @Override + public int hashCode() { + final int PRIME = 59; + int result = 1; + result = result * PRIME + this.getNode().hashCode(); + result = result * PRIME + this.getContexts().hashCode(); + return result; + } + + @Override + public String toString() { + return "PermissionLookupKey(node=" + this.getNode() + ", contexts=" + this.getContexts() + ")"; + } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java index 1dfe77b78..54262d39d 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedCollection.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.sponge.service.persisted; -import lombok.AccessLevel; -import lombok.Getter; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.collect.ImmutableCollection; @@ -57,15 +54,12 @@ import java.util.function.Predicate; /** * A simple persistable subject collection */ -@Getter public class PersistedCollection implements LPSubjectCollection { private final LuckPermsService service; private final String identifier; - @Getter(AccessLevel.NONE) private final SubjectCollection spongeProxy; - @Getter(AccessLevel.NONE) private final LoadingCache subjects = Caffeine.newBuilder() .build(s -> new PersistedSubject(s, getService(), PersistedCollection.this)); @@ -76,16 +70,26 @@ public class PersistedCollection implements LPSubjectCollection { } public void loadAll() { - Map holders = service.getStorage().loadAllFromFile(identifier); + Map holders = this.service.getStorage().loadAllFromFile(this.identifier); for (Map.Entry e : holders.entrySet()) { - PersistedSubject subject = subjects.get(e.getKey().toLowerCase()); + PersistedSubject subject = this.subjects.get(e.getKey().toLowerCase()); subject.loadData(e.getValue()); } } @Override public SubjectCollection sponge() { - return spongeProxy; + return this.spongeProxy; + } + + @Override + public LuckPermsService getService() { + return this.service; + } + + @Override + public String getIdentifier() { + return this.identifier; } @Override @@ -95,36 +99,36 @@ public class PersistedCollection implements LPSubjectCollection { @Override public CompletableFuture loadSubject(String identifier) { - return CompletableFuture.completedFuture(subjects.get(identifier.toLowerCase())); + return CompletableFuture.completedFuture(this.subjects.get(identifier.toLowerCase())); } @Override public Optional getSubject(String identifier) { - return Optional.of(subjects.get(identifier.toLowerCase())); + return Optional.of(this.subjects.get(identifier.toLowerCase())); } @Override public CompletableFuture hasRegistered(String identifier) { - return CompletableFuture.completedFuture(subjects.asMap().containsKey(identifier.toLowerCase())); + return CompletableFuture.completedFuture(this.subjects.asMap().containsKey(identifier.toLowerCase())); } @Override public CompletableFuture> loadSubjects(Set identifiers) { ImmutableSet.Builder ret = ImmutableSet.builder(); for (String id : identifiers) { - ret.add(subjects.get(id.toLowerCase())); + ret.add(this.subjects.get(id.toLowerCase())); } return CompletableFuture.completedFuture(ret.build()); } @Override public ImmutableCollection getLoadedSubjects() { - return ImmutableList.copyOf(subjects.asMap().values()); + return ImmutableList.copyOf(this.subjects.asMap().values()); } @Override public CompletableFuture> getAllIdentifiers() { - return CompletableFuture.completedFuture(ImmutableSet.copyOf(subjects.asMap().keySet())); + return CompletableFuture.completedFuture(ImmutableSet.copyOf(this.subjects.asMap().keySet())); } @Override @@ -142,7 +146,7 @@ public class PersistedCollection implements LPSubjectCollection { @Override public ImmutableMap getLoadedWithPermission(String permission) { ImmutableMap.Builder m = ImmutableMap.builder(); - for (LPSubject subject : subjects.asMap().values()) { + for (LPSubject subject : this.subjects.asMap().values()) { Tristate ts = subject.getPermissionValue(ImmutableContextSet.empty(), permission); if (ts != Tristate.UNDEFINED) { m.put(subject, ts.asBoolean()); @@ -155,7 +159,7 @@ public class PersistedCollection implements LPSubjectCollection { @Override public ImmutableMap getLoadedWithPermission(ImmutableContextSet contexts, String permission) { ImmutableMap.Builder m = ImmutableMap.builder(); - for (LPSubject subject : subjects.asMap().values()) { + for (LPSubject subject : this.subjects.asMap().values()) { Tristate ts = subject.getPermissionValue(contexts, permission); if (ts != Tristate.UNDEFINED) { m.put(subject, ts.asBoolean()); @@ -167,7 +171,7 @@ public class PersistedCollection implements LPSubjectCollection { @Override public LPSubject getDefaults() { - return service.getDefaultSubjects().loadSubject(getIdentifier()).join(); + return this.service.getDefaultSubjects().loadSubject(getIdentifier()).join(); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java index a6839219c..902540c09 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubject.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.sponge.service.persisted; -import lombok.Getter; -import lombok.NonNull; - import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.google.common.collect.ImmutableList; @@ -49,13 +46,13 @@ import org.spongepowered.api.service.permission.Subject; import java.io.IOException; import java.util.ArrayList; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.concurrent.TimeUnit; /** * A simple persistable Subject implementation */ -@Getter public class PersistedSubject implements LPSubject { private final String identifier; @@ -81,7 +78,7 @@ public class PersistedSubject implements LPSubject { @Override protected Void perform() { try { - service.getStorage().saveToFile(PersistedSubject.this); + PersistedSubject.this.service.getStorage().saveToFile(PersistedSubject.this); } catch (IOException e) { e.printStackTrace(); } @@ -100,21 +97,21 @@ public class PersistedSubject implements LPSubject { @Override public void invalidateCaches(CacheLevel type) { - optionLookupCache.invalidateAll(); + this.optionLookupCache.invalidateAll(); if (type == CacheLevel.OPTION) { return; } - permissionLookupCache.invalidateAll(); - subjectData.invalidateLookupCache(); - transientSubjectData.invalidateLookupCache(); + this.permissionLookupCache.invalidateAll(); + this.subjectData.invalidateLookupCache(); + this.transientSubjectData.invalidateLookupCache(); if (type == CacheLevel.PERMISSION) { return; } - parentLookupCache.invalidateAll(); + this.parentLookupCache.invalidateAll(); } @Override @@ -127,13 +124,13 @@ public class PersistedSubject implements LPSubject { } public void loadData(SubjectStorageModel dataHolder) { - subjectData.setSave(false); - dataHolder.applyToData(subjectData); - subjectData.setSave(true); + this.subjectData.setSave(false); + dataHolder.applyToData(this.subjectData); + this.subjectData.setSave(true); } public void save() { - saveBuffer.request(); + this.saveBuffer.request(); } @Override @@ -141,6 +138,31 @@ public class PersistedSubject implements LPSubject { return ProxyFactory.toSponge(this); } + @Override + public String getIdentifier() { + return this.identifier; + } + + @Override + public LuckPermsService getService() { + return this.service; + } + + @Override + public PersistedCollection getParentCollection() { + return this.parentCollection; + } + + @Override + public PersistedSubjectData getSubjectData() { + return this.subjectData; + } + + @Override + public CalculatedSubjectData getTransientSubjectData() { + return this.transientSubjectData; + } + @Override public Optional getCommandSource() { return Optional.empty(); @@ -150,23 +172,23 @@ public class PersistedSubject implements LPSubject { Tristate res; // if transient has priority - if (!parentCollection.getIdentifier().equals("defaults")) { - res = transientSubjectData.getPermissionValue(contexts, node); + if (!this.parentCollection.getIdentifier().equals("defaults")) { + res = this.transientSubjectData.getPermissionValue(contexts, node); if (res != Tristate.UNDEFINED) { return res; } - res = subjectData.getPermissionValue(contexts, node); + res = this.subjectData.getPermissionValue(contexts, node); if (res != Tristate.UNDEFINED) { return res; } } else { - res = subjectData.getPermissionValue(contexts, node); + res = this.subjectData.getPermissionValue(contexts, node); if (res != Tristate.UNDEFINED) { return res; } - res = transientSubjectData.getPermissionValue(contexts, node); + res = this.transientSubjectData.getPermissionValue(contexts, node); if (res != Tristate.UNDEFINED) { return res; } @@ -188,44 +210,44 @@ public class PersistedSubject implements LPSubject { return res; } - res = service.getDefaults().getPermissionValue(contexts, node); + res = this.service.getDefaults().getPermissionValue(contexts, node); return res; } private ImmutableList lookupParents(ImmutableContextSet contexts) { List s = new ArrayList<>(); - s.addAll(subjectData.getParents(contexts)); - s.addAll(transientSubjectData.getParents(contexts)); + s.addAll(this.subjectData.getParents(contexts)); + s.addAll(this.transientSubjectData.getParents(contexts)); if (!getParentCollection().getIdentifier().equalsIgnoreCase("defaults")) { s.addAll(getParentCollection().getDefaults().getParents(contexts)); - s.addAll(service.getDefaults().getParents(contexts)); + s.addAll(this.service.getDefaults().getParents(contexts)); } - return service.sortSubjects(s); + return this.service.sortSubjects(s); } private Optional lookupOptionValue(ImmutableContextSet contexts, String key) { Optional res; // if transient has priority - if (!parentCollection.getIdentifier().equals("defaults")) { - res = Optional.ofNullable(transientSubjectData.getOptions(contexts).get(key)); + if (!this.parentCollection.getIdentifier().equals("defaults")) { + res = Optional.ofNullable(this.transientSubjectData.getOptions(contexts).get(key)); if (res.isPresent()) { return res; } - res = Optional.ofNullable(subjectData.getOptions(contexts).get(key)); + res = Optional.ofNullable(this.subjectData.getOptions(contexts).get(key)); if (res.isPresent()) { return res; } } else { - res = Optional.ofNullable(subjectData.getOptions(contexts).get(key)); + res = Optional.ofNullable(this.subjectData.getOptions(contexts).get(key)); if (res.isPresent()) { return res; } - res = Optional.ofNullable(transientSubjectData.getOptions(contexts).get(key)); + res = Optional.ofNullable(this.transientSubjectData.getOptions(contexts).get(key)); if (res.isPresent()) { return res; } @@ -247,41 +269,48 @@ public class PersistedSubject implements LPSubject { return res; } - return service.getDefaults().getOption(contexts, key); + return this.service.getDefaults().getOption(contexts, key); } @Override - public Tristate getPermissionValue(@NonNull ImmutableContextSet contexts, @NonNull String node) { - Tristate t = permissionLookupCache.get(PermissionLookupKey.of(node, contexts)); - service.getPlugin().getVerboseHandler().offerCheckData(CheckOrigin.INTERNAL, getParentCollection().getIdentifier() + "/" + identifier, contexts, node, t); + public Tristate getPermissionValue(ImmutableContextSet contexts, String node) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(node, "node"); + + Tristate t = this.permissionLookupCache.get(PermissionLookupKey.of(node, contexts)); + this.service.getPlugin().getVerboseHandler().offerCheckData(CheckOrigin.INTERNAL, getParentCollection().getIdentifier() + "/" + this.identifier, contexts, node, t); return t; } @Override - public boolean isChildOf(@NonNull ImmutableContextSet contexts, @NonNull SubjectReference subject) { + public boolean isChildOf(ImmutableContextSet contexts, SubjectReference subject) { + Objects.requireNonNull(contexts, "contexts"); + Objects.requireNonNull(subject, "subject"); + if (getParentCollection().getIdentifier().equalsIgnoreCase("defaults")) { - return subjectData.getParents(contexts).contains(subject) || - transientSubjectData.getParents(contexts).contains(subject); + return this.subjectData.getParents(contexts).contains(subject) || + this.transientSubjectData.getParents(contexts).contains(subject); } else { - return subjectData.getParents(contexts).contains(subject) || - transientSubjectData.getParents(contexts).contains(subject) || + return this.subjectData.getParents(contexts).contains(subject) || + this.transientSubjectData.getParents(contexts).contains(subject) || getParentCollection().getDefaults().getParents(contexts).contains(subject) || - service.getDefaults().getParents(contexts).contains(subject); + this.service.getDefaults().getParents(contexts).contains(subject); } } @Override - public ImmutableList getParents(@NonNull ImmutableContextSet contexts) { - return parentLookupCache.get(contexts); + public ImmutableList getParents(ImmutableContextSet contexts) { + Objects.requireNonNull(contexts, "contexts"); + return this.parentLookupCache.get(contexts); } @Override public Optional getOption(ImmutableContextSet contexts, String key) { - return optionLookupCache.get(OptionLookupKey.of(key, contexts)); + return this.optionLookupCache.get(OptionLookupKey.of(key, contexts)); } @Override public ImmutableContextSet getActiveContextSet() { - return service.getPlugin().getContextManager().getApplicableContext(sponge()); + return this.service.getPlugin().getContextManager().getApplicableContext(sponge()); } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubjectData.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubjectData.java index fbf1489a9..330e98eed 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubjectData.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/persisted/PersistedSubjectData.java @@ -25,9 +25,6 @@ package me.lucko.luckperms.sponge.service.persisted; -import lombok.Getter; -import lombok.Setter; - import me.lucko.luckperms.api.Tristate; import me.lucko.luckperms.api.context.ImmutableContextSet; import me.lucko.luckperms.sponge.service.LuckPermsService; @@ -43,8 +40,6 @@ import java.util.function.Function; public class PersistedSubjectData extends CalculatedSubjectData implements Function { private final PersistedSubject subject; - @Getter - @Setter private boolean save = true; public PersistedSubjectData(LuckPermsService service, String calculatorDisplayName, PersistedSubject subject) { @@ -53,12 +48,12 @@ public class PersistedSubjectData extends CalculatedSubjectData implements Funct } private void save() { - if (!save) { + if (!this.save) { return; } - if (subject != null) { - subject.save(); + if (this.subject != null) { + this.subject.save(); } } @@ -122,4 +117,12 @@ public class PersistedSubjectData extends CalculatedSubjectData implements Funct public CompletableFuture clearOptions(ImmutableContextSet contexts) { return super.clearOptions(contexts).thenApply(this); } + + public boolean isSave() { + return this.save; + } + + public void setSave(boolean save) { + this.save = save; + } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorage.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorage.java index 19bae340d..1ad180e60 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorage.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorage.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.storage; -import lombok.Getter; - import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; import com.google.gson.Gson; @@ -55,7 +53,6 @@ public class SubjectStorage { private final LPPermissionService service; - @Getter private final Gson gson; private final File container; @@ -74,7 +71,7 @@ public class SubjectStorage { public Set getSavedCollections() { checkContainer(); - File[] dirs = container.listFiles(File::isDirectory); + File[] dirs = this.container.listFiles(File::isDirectory); if (dirs == null) { return Collections.emptySet(); } @@ -84,7 +81,7 @@ public class SubjectStorage { public File resolveFile(String collectionName, String subjectName) { checkContainer(); - File collection = new File(container, collectionName); + File collection = new File(this.container, collectionName); if (!collection.exists()) { collection.mkdirs(); } @@ -105,14 +102,14 @@ public class SubjectStorage { file.createNewFile(); try (BufferedWriter writer = Files.newBufferedWriter(file.toPath(), StandardCharsets.UTF_8)) { - gson.toJson(model.toJson(), writer); + this.gson.toJson(model.toJson(), writer); writer.flush(); } } public Map loadAllFromFile(String collectionName) { checkContainer(); - File collection = new File(container, collectionName); + File collection = new File(this.container, collectionName); if (!collection.exists()) { return Collections.emptyMap(); } @@ -139,7 +136,7 @@ public class SubjectStorage { public Map.Entry loadFromFile(String collectionName, String subjectName) throws IOException { checkContainer(); - File collection = new File(container, collectionName); + File collection = new File(this.container, collectionName); if (!collection.exists()) { return null; } @@ -156,10 +153,13 @@ public class SubjectStorage { String subjectName = file.getName().substring(0, file.getName().length() - ".json".length()); try (BufferedReader reader = Files.newBufferedReader(file.toPath(), StandardCharsets.UTF_8)) { - JsonObject data = gson.fromJson(reader, JsonObject.class); - SubjectStorageModel model = new SubjectStorageModel(service, data); + JsonObject data = this.gson.fromJson(reader, JsonObject.class); + SubjectStorageModel model = new SubjectStorageModel(this.service, data); return Maps.immutableEntry(subjectName, model); } } + public Gson getGson() { + return this.gson; + } } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorageModel.java b/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorageModel.java index bbed38767..3124e1b83 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorageModel.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/service/storage/SubjectStorageModel.java @@ -25,8 +25,6 @@ package me.lucko.luckperms.sponge.service.storage; -import lombok.Getter; - import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; @@ -50,7 +48,6 @@ import java.util.Map; /** * Used for converting a SubjectData instance to and from JSON */ -@Getter public class SubjectStorageModel { private final LPPermissionService service; private final Map> permissions; @@ -256,8 +253,13 @@ public class SubjectStorageModel { } public void applyToData(CalculatedSubjectData subjectData) { - subjectData.replacePermissions(permissions); - subjectData.replaceOptions(options); - subjectData.replaceParents(parents); + subjectData.replacePermissions(this.permissions); + subjectData.replaceOptions(this.options); + subjectData.replaceParents(this.parents); } + + public LPPermissionService getService() { + return this.service; + } + } diff --git a/sponge/src/main/java/me/lucko/luckperms/sponge/tasks/ServiceCacheHousekeepingTask.java b/sponge/src/main/java/me/lucko/luckperms/sponge/tasks/ServiceCacheHousekeepingTask.java index ac32bdc66..a7a97ad27 100644 --- a/sponge/src/main/java/me/lucko/luckperms/sponge/tasks/ServiceCacheHousekeepingTask.java +++ b/sponge/src/main/java/me/lucko/luckperms/sponge/tasks/ServiceCacheHousekeepingTask.java @@ -25,19 +25,20 @@ package me.lucko.luckperms.sponge.tasks; -import lombok.RequiredArgsConstructor; - import me.lucko.luckperms.sponge.service.LuckPermsService; import me.lucko.luckperms.sponge.service.model.LPSubject; import me.lucko.luckperms.sponge.service.model.LPSubjectCollection; -@RequiredArgsConstructor public class ServiceCacheHousekeepingTask implements Runnable { private final LuckPermsService service; + public ServiceCacheHousekeepingTask(LuckPermsService service) { + this.service = service; + } + @Override public void run() { - for (LPSubjectCollection collection : service.getLoadedCollections().values()) { + for (LPSubjectCollection collection : this.service.getLoadedCollections().values()) { for (LPSubject subject : collection.getLoadedSubjects()) { subject.performCleanup(); }