1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
local domain = require("clever_f.domain")
local M = {}
local AcquisitionRequest = {}
local AcquisitionService = {}
AcquisitionService.__index = AcquisitionService
M.AcquisitionRequest = AcquisitionRequest
M.AcquisitionService = AcquisitionService
M.RepeatedDirection = {
SAME = "same",
}
local request_records = setmetatable({}, { __mode = "k" })
local service_records = setmetatable({}, { __mode = "k" })
local function fail(message, level)
error(message, (level or 1) + 1)
end
local function normalize_macro_state(value)
if type(value) == "table" and not domain.MacroState.is(value) then
value = value.register
end
return domain.MacroState.new(value)
end
local request_metatable = {
__index = function(request, key)
local method = AcquisitionRequest[key]
if method ~= nil then
return method
end
return request_records[request][key]
end,
__newindex = function()
fail("AcquisitionRequest values are immutable", 2)
end,
__tostring = function(request)
return "acquisition-request:" .. request_records[request].descriptor.value
end,
__metatable = "clever_f.acquisition_service.AcquisitionRequest",
}
function AcquisitionRequest.new(descriptor, context, position, count, macro_state)
if AcquisitionRequest.is(descriptor) then
return descriptor
end
if type(descriptor) == "table" and not domain.Descriptor.is(descriptor) then
local options = descriptor
descriptor = options.descriptor
context = options.context
position = options.position or options.origin
count = options.count
macro_state = options.macro_state
end
local request = setmetatable({}, request_metatable)
request_records[request] = {
descriptor = domain.Descriptor.from_string(descriptor),
context = domain.ModeContext.from_full_mode(context),
position = domain.Position.coerce(position),
count = domain.Count.new(count),
macro_state = normalize_macro_state(macro_state),
repeated_direction = M.RepeatedDirection.SAME,
}
return request
end
function AcquisitionRequest.is(value)
return type(value) == "table" and request_records[value] ~= nil
end
function AcquisitionRequest:to_table()
return {
descriptor = self.descriptor.value,
context = self.context.key,
position = self.position:to_table(),
count = self.count.value,
macro_register = self.macro_state.register,
repeated_direction = self.repeated_direction,
}
end
local function normalize_options(options, dependencies)
if AcquisitionService.is(options) and dependencies == nil then
return options
end
if type(options) ~= "table" then
fail("AcquisitionService options must be a table", 3)
end
if options.host ~= nil then
if dependencies ~= nil then
fail("AcquisitionService dependencies must be part of its options", 3)
end
return options
end
local result = {}
for key, value in pairs(dependencies or {}) do
result[key] = value
end
result.host = options
return result
end
function AcquisitionService.new(options, dependencies)
options = normalize_options(options, dependencies)
if AcquisitionService.is(options) then
return options
end
if type(options.host) ~= "table" then
fail("AcquisitionService host must be a table", 2)
end
local service = setmetatable({}, AcquisitionService)
service_records[service] = {
host = options.host,
}
return service
end
function AcquisitionService.is(value)
return type(value) == "table" and service_records[value] ~= nil
end
function AcquisitionService:request(descriptor, context, position, count, macro_state)
return AcquisitionRequest.new(descriptor, context, position, count, macro_state)
end
function AcquisitionService:acquire(descriptor, context, position, count, macro_state)
return self:request(descriptor, context, position, count, macro_state)
end
function M.new(options, dependencies)
return AcquisitionService.new(options, dependencies)
end
setmetatable(M, {
__call = function(_, options, dependencies)
return AcquisitionService.new(options, dependencies)
end,
})
return M
|
