Java tutorial
/** * PermissionsEx * Copyright (C) zml and PermissionsEx contributors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package ninja.leaping.permissionsex.backend.sql; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import ninja.leaping.permissionsex.data.ImmutableSubjectData; import ninja.leaping.permissionsex.util.ThrowingBiConsumer; import ninja.leaping.permissionsex.util.Util; import java.sql.SQLException; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; /** * Data for SQL-backed subjects */ class SqlSubjectData implements ImmutableSubjectData { private final SubjectRef subject; private final Map<Set<Entry<String, String>>, Segment> segments; private final AtomicReference<ImmutableList<ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException>>> updatesToPerform = new AtomicReference<>(); SqlSubjectData(SubjectRef subject) { this(subject, ImmutableMap.of(), null); } SqlSubjectData(SubjectRef subject, Map<Set<Entry<String, String>>, Segment> segments, ImmutableList<ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException>> updates) { this.subject = subject; this.segments = segments; this.updatesToPerform.set(updates); } protected final SqlSubjectData newWithUpdate(Map<Set<Entry<String, String>>, Segment> segments, ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException> updateFunc) { return new SqlSubjectData(subject, segments, Util.appendImmutable(this.updatesToPerform.get(), updateFunc)); } protected final SqlSubjectData newWithUpdated(Set<Entry<String, String>> key, Segment val) { ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException> updateFunc; if (val.isEmpty()) { // then remove segment if (val.isUnallocated()) { updateFunc = (dao, data) -> { }; } else { updateFunc = (dao, data) -> dao.removeSegment(val); } } else if (val.isUnallocated()) { // create new segment updateFunc = (dao, data) -> { Segment seg = data.segments.get(key); if (seg != null) { if (seg.isUnallocated()) { seg.popUpdates(); dao.updateFullSegment(data.subject, seg); } else { seg.doUpdates(dao); } } }; } else { // just run updates updateFunc = (dao, data) -> { val.doUpdates(dao); }; } return newWithUpdate(Util.updateImmutable(segments, immutSet(key), val), updateFunc); } private Segment getSegmentOrNew(Set<Entry<String, String>> segments) { Segment res = this.segments.get(segments); if (res == null) { res = Segment.unallocated(); } return res; } private <E> ImmutableSet<E> immutSet(Set<E> set) { return ImmutableSet.copyOf(set); } @Override public Map<Set<Entry<String, String>>, Map<String, String>> getAllOptions() { return Maps.filterValues( Maps.transformValues(segments, dataEntry -> dataEntry == null ? null : dataEntry.getOptions()), el -> el != null); } @Override public Map<String, String> getOptions(Set<Entry<String, String>> segments) { final Segment entry = this.segments.get(segments); return entry == null || entry.getOptions() == null ? Collections.emptyMap() : entry.getOptions(); } @Override public ImmutableSubjectData setOption(Set<Entry<String, String>> segments, String key, String value) { if (value == null) { return newWithUpdated(segments, getSegmentOrNew(segments).withoutOption(key)); } else { return newWithUpdated(segments, getSegmentOrNew(segments).withOption(key, value)); } } @Override public ImmutableSubjectData setOptions(Set<Entry<String, String>> segments, Map<String, String> values) { return newWithUpdated(segments, getSegmentOrNew(segments).withOptions(values)); } @Override public ImmutableSubjectData clearOptions(Set<Entry<String, String>> segments) { if (!this.segments.containsKey(segments)) { return this; } return newWithUpdated(segments, getSegmentOrNew(segments).withoutOptions()); } @Override public ImmutableSubjectData clearOptions() { if (this.segments.isEmpty()) { return this; } Map<Set<Entry<String, String>>, Segment> newValue = Maps.transformValues(this.segments, dataEntry -> dataEntry == null ? null : dataEntry.withoutOptions()); return newWithUpdate(newValue, createBulkUpdateFunc(newValue.keySet())); } private ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException> createBulkUpdateFunc( Collection<Set<Entry<String, String>>> keys) { return (dao, data) -> { for (Set<Entry<String, String>> key : keys) { Segment seg = data.segments.get(key); if (seg != null) { if (seg.isEmpty()) { dao.removeSegment(seg); } else { seg.doUpdates(dao); } } } }; } @Override public Map<Set<Entry<String, String>>, Map<String, Integer>> getAllPermissions() { return Maps.filterValues( Maps.transformValues(segments, dataEntry -> dataEntry == null ? null : dataEntry.getPermissions()), o -> o != null); } @Override public Map<String, Integer> getPermissions(Set<Entry<String, String>> set) { final Segment entry = this.segments.get(set); return entry == null || entry.getPermissions() == null ? Collections.emptyMap() : entry.getPermissions(); } @Override public ImmutableSubjectData setPermission(Set<Entry<String, String>> segments, String permission, int value) { if (value == 0) { return newWithUpdated(segments, getSegmentOrNew(segments).withoutPermission(permission)); } else { return newWithUpdated(segments, getSegmentOrNew(segments).withPermission(permission, value)); } } @Override public ImmutableSubjectData setPermissions(Set<Entry<String, String>> segments, Map<String, Integer> values) { return newWithUpdated(segments, getSegmentOrNew(segments).withPermissions(values)); } @Override public ImmutableSubjectData clearPermissions() { if (this.segments.isEmpty()) { return this; } Map<Set<Entry<String, String>>, Segment> newValue = Maps.transformValues(this.segments, dataEntry -> dataEntry == null ? null : dataEntry.withoutPermissions()); return newWithUpdate(newValue, createBulkUpdateFunc(newValue.keySet())); } @Override public ImmutableSubjectData clearPermissions(Set<Entry<String, String>> segments) { if (!this.segments.containsKey(segments)) { return this; } return newWithUpdated(segments, getSegmentOrNew(segments).withoutPermissions()); } @Override public Map<Set<Entry<String, String>>, List<Entry<String, String>>> getAllParents() { return Maps.filterValues( Maps.transformValues(segments, dataEntry -> dataEntry == null ? null : dataEntry.getParents() == null ? null : ImmutableList.copyOf(dataEntry.getParents())), v -> v != null); } @Override public List<Entry<String, String>> getParents(Set<Entry<String, String>> segments) { Segment ent = this.segments.get(segments); return ent == null || ent.getParents() == null ? Collections.emptyList() : ImmutableList.copyOf(ent.getParents()); } @Override public ImmutableSubjectData addParent(Set<Entry<String, String>> segments, String type, String ident) { Segment entry = getSegmentOrNew(segments); final SubjectRef parentIdent = SubjectRef.unresolved(type, ident); if (entry.getParents() != null && entry.getParents().contains(parentIdent)) { return this; } return newWithUpdated(segments, entry.withAddedParent(parentIdent)); } @Override public ImmutableSubjectData removeParent(Set<Entry<String, String>> segments, String type, String identifier) { Segment ent = this.segments.get(segments); if (ent == null) { return this; } final SubjectRef parentIdent = SubjectRef.unresolved(type, identifier); if (ent.getParents() == null || !ent.getParents().contains(parentIdent)) { return this; } return newWithUpdated(segments, ent.withRemovedParent(parentIdent)); } @Override public ImmutableSubjectData setParents(Set<Entry<String, String>> segments, List<Entry<String, String>> parents) { Segment entry = getSegmentOrNew(segments); return newWithUpdated(segments, entry.withParents(Lists.transform(parents, ent -> ent instanceof SubjectRef ? (SubjectRef) ent : SubjectRef.unresolved(ent.getKey(), ent.getValue())))); } @Override public ImmutableSubjectData clearParents() { if (this.segments.isEmpty()) { return this; } Map<Set<Entry<String, String>>, Segment> newValue = Maps.transformValues(this.segments, dataEntry -> dataEntry == null ? null : dataEntry.withoutParents()); return newWithUpdate(newValue, createBulkUpdateFunc(newValue.keySet())); } @Override public ImmutableSubjectData clearParents(Set<Entry<String, String>> segments) { if (!this.segments.containsKey(segments)) { return this; } return newWithUpdated(segments, getSegmentOrNew(segments).withoutParents()); } @Override public int getDefaultValue(Set<Entry<String, String>> segments) { Segment ent = this.segments.get(segments); return ent == null || ent.getPermissionDefault() == null ? 0 : ent.getPermissionDefault(); } @Override public ImmutableSubjectData setDefaultValue(Set<Entry<String, String>> segments, int defaultValue) { return newWithUpdated(segments, getSegmentOrNew(segments).withDefaultValue(defaultValue)); } @Override public Iterable<Set<Entry<String, String>>> getActiveContexts() { return segments.keySet(); } @Override public Map<Set<Entry<String, String>>, Integer> getAllDefaultValues() { return Maps.filterValues(Maps.transformValues(segments, dataEntry -> dataEntry == null ? null : dataEntry.getPermissionDefault()), v -> v != null); } public void doUpdates(SqlDao dao) throws SQLException { dao.executeInTransaction(() -> { List<ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException>> updates = this.updatesToPerform .getAndSet(null); if (updates != null) { for (ThrowingBiConsumer<SqlDao, SqlSubjectData, SQLException> func : updates) { func.accept(dao, this); } } return null; }); } }