Skip to content

Commit 2ef47e4

Browse files
zamderaxzamderax
committed
refactor(adapter): move async/await overloads into MemoryAdapter+AsyncAwait.swift for clarity
1 parent 442b2a2 commit 2ef47e4

File tree

2 files changed

+172
-154
lines changed

2 files changed

+172
-154
lines changed

‎Sources/Casbin/Adapter/MemoryAdapter+AsyncAwait.swift‎

Lines changed: 163 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,163 @@
1+
import NIO
2+
3+
// Async/Await overloads for MemoryAdapter
4+
extension MemoryAdapter {
5+
6+
// MARK: Load
7+
public func loadPolicy(m: Model) async throws {
8+
for line in policy {
9+
let sec = line[0]
10+
let ptype = line[1]
11+
let rule = Array(line.dropFirst(2))
12+
if let ast = m.getModel()[sec]?[ptype] {
13+
ast.policy.append(rule)
14+
}
15+
}
16+
}
17+
18+
public func loadFilteredPolicy(m: Model, f: Filter) async throws {
19+
for line in policy {
20+
let sec = line[0]
21+
let ptype = line[1]
22+
let rule = Array(line.dropFirst(2))
23+
var isFiltered = false
24+
if sec == "p" {
25+
for (i,r) in f.p.enumerated() {
26+
if !r.isEmpty && r != rule[i] {
27+
isFiltered = true
28+
}
29+
}
30+
}
31+
if sec == "g" {
32+
for (i,r) in f.g.enumerated() {
33+
if !r.isEmpty && r != rule[i] {
34+
isFiltered = true
35+
}
36+
}
37+
}
38+
if !isFiltered {
39+
if let ast = m.getModel()[sec]?[ptype] {
40+
ast.policy.append(rule)
41+
}
42+
} else {
43+
self.isFiltered = true
44+
}
45+
}
46+
}
47+
48+
// MARK: Save / Clear
49+
public func savePolicy(m: Model) async throws {
50+
self.policy = []
51+
if let astMap = m.getModel()["p"] {
52+
for (ptype,ast) in astMap {
53+
for policy in ast.policy {
54+
var rule = policy
55+
rule.insert(ptype, at: 0)
56+
rule.insert("p", at: 0)
57+
self.policy.insert(rule)
58+
}
59+
}
60+
}
61+
if let astMap = m.getModel()["g"] {
62+
for (ptype,ast) in astMap {
63+
for policy in ast.policy {
64+
var rule = policy
65+
rule.insert(ptype, at: 0)
66+
rule.insert("g", at: 0)
67+
self.policy.insert(rule)
68+
}
69+
}
70+
}
71+
}
72+
73+
public func clearPolicy() async throws {
74+
self.policy = []
75+
self.isFiltered = false
76+
}
77+
78+
// MARK: Add
79+
public func addPolicy(sec: String, ptype: String, rule: [String]) async throws -> Bool {
80+
var rule = rule
81+
rule.insert(ptype, at: 0)
82+
rule.insert(sec, at: 0)
83+
return self.policy.insert(rule).inserted
84+
}
85+
86+
public func addPolicies(sec: String, ptype: String, rules: [[String]]) async throws -> Bool {
87+
var allAdded = true
88+
let rules: [[String]] = rules.map { r in
89+
var r = r
90+
r.insert(ptype, at: 0)
91+
r.insert(sec, at: 0)
92+
return r
93+
}
94+
for rule in rules {
95+
if policy.contains(rule) {
96+
allAdded = false
97+
return allAdded
98+
}
99+
}
100+
self.policy = self.policy.union(rules)
101+
return allAdded
102+
}
103+
104+
// MARK: Remove
105+
public func removePolicy(sec: String, ptype: String, rule: [String]) async throws -> Bool {
106+
var rule = rule
107+
rule.insert(ptype, at: 0)
108+
rule.insert(sec, at: 0)
109+
return policy.remove(rule) != nil
110+
}
111+
112+
public func removePolicies(sec: String, ptype: String, rules: [[String]]) async throws -> Bool {
113+
var allRemoved = true
114+
let rules: [[String]] = rules.map { r in
115+
var r = r
116+
r.insert(ptype, at: 0)
117+
r.insert(sec, at: 0)
118+
return r
119+
}
120+
// Atomic semantics: if any rule doesn't exist, do not remove any and return false
121+
for rule in rules {
122+
if !policy.contains(rule) {
123+
allRemoved = false
124+
break
125+
}
126+
}
127+
if allRemoved {
128+
for rule in rules {
129+
_ = self.policy.remove(rule)
130+
}
131+
}
132+
return allRemoved
133+
}
134+
135+
public func removeFilteredPolicy(sec: String, ptype: String, fieldIndex: Int, fieldValues: [String]) async throws -> Bool {
136+
if fieldValues.isEmpty {
137+
return false
138+
}
139+
var tmp: Set<[String]> = []
140+
var res = false
141+
for rule in policy {
142+
if sec == rule[0] && ptype == rule[1] {
143+
var matched = true
144+
for (i, fieldValue) in fieldValues.enumerated() {
145+
if !fieldValue.isEmpty && rule[fieldIndex + i + 2] != fieldValue {
146+
matched = false
147+
break
148+
}
149+
}
150+
if matched {
151+
res = true
152+
} else {
153+
tmp.insert(rule)
154+
}
155+
} else {
156+
tmp.insert(rule)
157+
}
158+
}
159+
self.policy = tmp
160+
return res
161+
}
162+
}
163+

‎Sources/Casbin/Adapter/MemoryAdapter.swift‎

Lines changed: 9 additions & 154 deletions
Original file line numberDiff line numberDiff line change
@@ -40,17 +40,7 @@ extension MemoryAdapter: Adapter {
4040
return eventloop.makeSucceededVoidFuture()
4141
}
4242

43-
/// Async/await version of loadPolicy for Swift 6 concurrency
44-
public func loadPolicy(m: Model) async throws {
45-
for line in policy {
46-
let sec = line[0]
47-
let ptype = line[1]
48-
let rule = Array(line.dropFirst(2))
49-
if let ast = m.getModel()[sec]?[ptype] {
50-
ast.policy.append(rule)
51-
}
52-
}
53-
}
43+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
5444

5545
public func loadFilteredPolicy(m: Model, f: Filter) -> EventLoopFuture<Void> {
5646
for line in policy {
@@ -83,36 +73,7 @@ extension MemoryAdapter: Adapter {
8373
return eventloop.makeSucceededVoidFuture()
8474
}
8575

86-
/// Async/await version of loadFilteredPolicy for Swift 6 concurrency
87-
public func loadFilteredPolicy(m: Model, f: Filter) async throws {
88-
for line in policy {
89-
let sec = line[0]
90-
let ptype = line[1]
91-
let rule = Array(line.dropFirst(2))
92-
var isFiltered = false
93-
if sec == "p" {
94-
for (i,r) in f.p.enumerated() {
95-
if !r.isEmpty && r != rule[i] {
96-
isFiltered = true
97-
}
98-
}
99-
}
100-
if sec == "g" {
101-
for (i,r) in f.g.enumerated() {
102-
if !r.isEmpty && r != rule[i] {
103-
isFiltered = true
104-
}
105-
}
106-
}
107-
if !isFiltered {
108-
if let ast = m.getModel()[sec]?[ptype] {
109-
ast.policy.append(rule)
110-
}
111-
} else {
112-
self.isFiltered = true
113-
}
114-
}
115-
}
76+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
11677

11778
public func savePolicy(m: Model) -> EventLoopFuture<Void> {
11879
self.policy = []
@@ -139,42 +100,15 @@ extension MemoryAdapter: Adapter {
139100
return eventloop.makeSucceededVoidFuture()
140101
}
141102

142-
/// Async/await version of savePolicy for Swift 6 concurrency
143-
public func savePolicy(m: Model) async throws {
144-
self.policy = []
145-
if let astMap = m.getModel()["p"] {
146-
for (ptype,ast) in astMap {
147-
for policy in ast.policy {
148-
var rule = policy
149-
rule.insert(ptype, at: 0)
150-
rule.insert("p", at: 0)
151-
self.policy.insert(rule)
152-
}
153-
}
154-
}
155-
if let astMap = m.getModel()["g"] {
156-
for (ptype,ast) in astMap {
157-
for policy in ast.policy {
158-
var rule = policy
159-
rule.insert(ptype, at: 0)
160-
rule.insert("g", at: 0)
161-
self.policy.insert(rule)
162-
}
163-
}
164-
}
165-
}
103+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
166104

167105
public func clearPolicy() -> EventLoopFuture<Void> {
168106
self.policy = []
169107
self.isFiltered = false
170108
return eventloop.makeSucceededVoidFuture()
171109
}
172110

173-
/// Async/await version of clearPolicy for Swift 6 concurrency
174-
public func clearPolicy() async throws {
175-
self.policy = []
176-
self.isFiltered = false
177-
}
111+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
178112

179113
public func addPolicy(sec: String, ptype: String, rule: [String]) -> EventLoopFuture<Bool> {
180114
var rule = rule
@@ -183,13 +117,7 @@ extension MemoryAdapter: Adapter {
183117
return eventloop.makeSucceededFuture(self.policy.insert(rule).inserted)
184118
}
185119

186-
/// Async/await version of addPolicy for Swift 6 concurrency
187-
public func addPolicy(sec: String, ptype: String, rule: [String]) async throws -> Bool {
188-
var rule = rule
189-
rule.insert(ptype, at: 0)
190-
rule.insert(sec, at: 0)
191-
return self.policy.insert(rule).inserted
192-
}
120+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
193121

194122
public func addPolicies(sec: String, ptype: String, rules: [[String]]) -> EventLoopFuture<Bool> {
195123
var allAdded = true
@@ -209,24 +137,7 @@ extension MemoryAdapter: Adapter {
209137
return eventloop.makeSucceededFuture(allAdded)
210138
}
211139

212-
/// Async/await version of addPolicies for Swift 6 concurrency
213-
public func addPolicies(sec: String, ptype: String, rules: [[String]]) async throws -> Bool {
214-
var allAdded = true
215-
let rules:[[String]] = rules.map { rule in
216-
var rule = rule
217-
rule.insert(ptype, at: 0)
218-
rule.insert(sec, at: 0)
219-
return rule
220-
}
221-
for rule in rules {
222-
if policy.contains(rule) {
223-
allAdded = false
224-
return allAdded
225-
}
226-
}
227-
self.policy = self.policy.union(rules)
228-
return allAdded
229-
}
140+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
230141

231142
public func removePolicy(sec: String, ptype: String, rule: [String]) -> EventLoopFuture<Bool> {
232143
var rule = rule
@@ -235,13 +146,7 @@ extension MemoryAdapter: Adapter {
235146
return eventloop.makeSucceededFuture(policy.remove(rule) != nil)
236147
}
237148

238-
/// Async/await version of removePolicy for Swift 6 concurrency
239-
public func removePolicy(sec: String, ptype: String, rule: [String]) async throws -> Bool {
240-
var rule = rule
241-
rule.insert(ptype, at: 0)
242-
rule.insert(sec, at: 0)
243-
return policy.remove(rule) != nil
244-
}
149+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
245150

246151
public func removePolicies(sec: String, ptype: String, rules: [[String]]) -> EventLoopFuture<Bool> {
247152
var allRemoved = true
@@ -266,29 +171,7 @@ extension MemoryAdapter: Adapter {
266171
return eventloop.makeSucceededFuture(allRemoved)
267172
}
268173

269-
/// Async/await version of removePolicies for Swift 6 concurrency
270-
public func removePolicies(sec: String, ptype: String, rules: [[String]]) async throws -> Bool {
271-
var allRemoved = true
272-
let rules:[[String]] = rules.map { rule in
273-
var rule = rule
274-
rule.insert(ptype, at: 0)
275-
rule.insert(sec, at: 0)
276-
return rule
277-
}
278-
// Atomic semantics
279-
for rule in rules {
280-
if !policy.contains(rule) {
281-
allRemoved = false
282-
break
283-
}
284-
}
285-
if allRemoved {
286-
for rule in rules {
287-
_ = self.policy.remove(rule)
288-
}
289-
}
290-
return allRemoved
291-
}
174+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
292175

293176
public func removeFilteredPolicy(sec: String, ptype: String, fieldIndex: Int, fieldValues: [String]) -> EventLoopFuture<Bool> {
294177
if fieldValues.isEmpty {
@@ -319,33 +202,5 @@ extension MemoryAdapter: Adapter {
319202
return eventloop.makeSucceededFuture(res)
320203
}
321204

322-
/// Async/await version of removeFilteredPolicy for Swift 6 concurrency
323-
public func removeFilteredPolicy(sec: String, ptype: String, fieldIndex: Int, fieldValues: [String]) async throws -> Bool {
324-
if fieldValues.isEmpty {
325-
return false
326-
}
327-
var tmp:Set<[String]> = []
328-
var res = false
329-
for rule in policy {
330-
if sec == rule[0] && ptype == rule [1] {
331-
var matched = true
332-
for (i,fieldValue) in fieldValues.enumerated() {
333-
if !fieldValue.isEmpty
334-
&& rule[fieldIndex + i + 2] != fieldValue {
335-
matched = false
336-
break
337-
}
338-
}
339-
if matched {
340-
res = true
341-
} else {
342-
tmp.insert(rule)
343-
}
344-
} else {
345-
tmp.insert(rule)
346-
}
347-
}
348-
self.policy = tmp
349-
return res
350-
}
205+
// Async/await overloads moved to MemoryAdapter+AsyncAwait.swift
351206
}

0 commit comments

Comments
 (0)