util-sto.lua /size: 6661 b    last modification: 2020-07-01 14:35
1
if
not
modules
then
modules
=
{
}
end
modules
[
'
util-sto
'
]
=
{
2
version
=
1
.
001
,
3
comment
=
"
companion to luat-lib.mkiv
"
,
4
author
=
"
Hans Hagen, PRAGMA-ADE, Hasselt NL
"
,
5
copyright
=
"
PRAGMA ADE / ConTeXt Development Team
"
,
6
license
=
"
see context related readme files
"
7
}
8 9
local
setmetatable
,
getmetatable
,
rawset
,
type
=
setmetatable
,
getmetatable
,
rawset
,
type
10 11
utilities
=
utilities
or
{
}
12
utilities
.
storage
=
utilities
.
storage
or
{
}
13
local
storage
=
utilities
.
storage
14 15
function
storage
.
mark
(
t
)
16
if
not
t
then
17
print
(
"
\nfatal error: storage cannot be marked\n
"
)
18
os
.
exit
(
)
19
return
20
end
21
local
m
=
getmetatable
(
t
)
22
if
not
m
then
23
m
=
{
}
24
setmetatable
(
t
,
m
)
25
end
26
m
.
__storage__
=
true
27
return
t
28
end
29 30
function
storage
.
allocate
(
t
)
31
t
=
t
or
{
}
32
local
m
=
getmetatable
(
t
)
33
if
not
m
then
34
m
=
{
}
35
setmetatable
(
t
,
m
)
36
end
37
m
.
__storage__
=
true
38
return
t
39
end
40 41
function
storage
.
marked
(
t
)
42
local
m
=
getmetatable
(
t
)
43
return
m
and
m
.
__storage__
44
end
45 46
function
storage
.
checked
(
t
)
47
if
not
t
then
48
report
(
"
\nfatal error: storage has not been allocated\n
"
)
49
os
.
exit
(
)
50
return
51
end
52
return
t
53
end
54 55
-- function utilities.storage.delay(parent,name,filename)
56
-- local m = getmetatable(parent)
57
-- m.__list[name] = filename
58
-- end
59
--
60
-- function utilities.storage.predefine(parent)
61
-- local list = { }
62
-- local m = getmetatable(parent) or {
63
-- __list = list,
64
-- __index = function(t,k)
65
-- local l = require(list[k])
66
-- t[k] = l
67
-- return l
68
-- end
69
-- }
70
-- setmetatable(parent,m)
71
-- end
72
--
73
-- bla = { }
74
-- utilities.storage.predefine(bla)
75
-- utilities.storage.delay(bla,"test","oepsoeps")
76
-- local t = bla.test
77
-- table.print(t)
78
-- print(t.a)
79 80
function
storage
.
setinitializer
(
data
,
initialize
)
81
local
m
=
getmetatable
(
data
)
or
{
}
82
m
.
__index
=
function
(
data
,
k
)
83
m
.
__index
=
nil
-- so that we can access the entries during initializing
84
initialize
(
)
85
return
data
[
k
]
86
end
87
setmetatable
(
data
,
m
)
88
end
89 90
local
keyisvalue
=
{
__index
=
function
(
t
,
k
)
91
t
[
k
]
=
k
92
return
k
93
end
}
94 95
function
storage
.
sparse
(
t
)
96
t
=
t
or
{
}
97
setmetatable
(
t
,
keyisvalue
)
98
return
t
99
end
100 101
-- table namespace ?
102 103
local
function
f_empty
(
)
return
"
"
end
-- t,k
104
local
function
f_self
(
t
,
k
)
t
[
k
]
=
k
return
k
end
105
local
function
f_table
(
t
,
k
)
local
v
=
{
}
t
[
k
]
=
v
return
v
end
106
local
function
f_number
(
t
,
k
)
t
[
k
]
=
0
return
0
end
-- t,k,v
107
local
function
f_ignore
(
)
end
-- t,k,v
108 109
local
f_index
=
{
110
[
"
empty
"
]
=
f_empty
,
111
[
"
self
"
]
=
f_self
,
112
[
"
table
"
]
=
f_table
,
113
[
"
number
"
]
=
f_number
,
114
}
115 116
function
table
.
setmetatableindex
(
t
,
f
)
117
if
type
(
t
)
~
=
"
table
"
then
118
f
,
t
=
t
,
{
}
119
end
120
local
m
=
getmetatable
(
t
)
121
local
i
=
f_index
[
f
]
or
f
122
if
m
then
123
m
.
__index
=
i
124
else
125
setmetatable
(
t
,
{
__index
=
i
}
)
126
end
127
return
t
128
end
129 130
local
f_index
=
{
131
[
"
ignore
"
]
=
f_ignore
,
132
}
133 134
function
table
.
setmetatablenewindex
(
t
,
f
)
135
if
type
(
t
)
~
=
"
table
"
then
136
f
,
t
=
t
,
{
}
137
end
138
local
m
=
getmetatable
(
t
)
139
local
i
=
f_index
[
f
]
or
f
140
if
m
then
141
m
.
__newindex
=
i
142
else
143
setmetatable
(
t
,
{
__newindex
=
i
}
)
144
end
145
return
t
146
end
147 148
function
table
.
setmetatablecall
(
t
,
f
)
149
if
type
(
t
)
~
=
"
table
"
then
150
f
,
t
=
t
,
{
}
151
end
152
local
m
=
getmetatable
(
t
)
153
if
m
then
154
m
.
__call
=
f
155
else
156
setmetatable
(
t
,
{
__call
=
f
}
)
157
end
158
return
t
159
end
160 161
-- the manual is somewhat fuzzy about this but suggests that one can best
162
-- set all fields before assigning a metatable
163 164
function
table
.
setmetatableindices
(
t
,
f
,
n
,
c
)
165
if
type
(
t
)
~
=
"
table
"
then
166
f
,
t
=
t
,
{
}
167
end
168
local
m
=
getmetatable
(
t
)
169
local
i
=
f_index
[
f
]
or
f
170
if
m
then
171
m
.
__index
=
i
172
m
.
__newindex
=
n
173
m
.
__call
=
c
174
else
175
setmetatable
(
t
,
{
176
__index
=
i
,
177
__newindex
=
n
,
178
__call
=
c
,
179
}
)
180
end
181
return
t
182
end
183 184
function
table
.
setmetatablekey
(
t
,
key
,
value
)
185
local
m
=
getmetatable
(
t
)
186
if
not
m
then
187
m
=
{
}
188
setmetatable
(
t
,
m
)
189
end
190
m
[
key
]
=
value
191
return
t
192
end
193 194
function
table
.
getmetatablekey
(
t
,
key
,
value
)
195
local
m
=
getmetatable
(
t
)
196
return
m
and
m
[
key
]
197
end
198 199
function
table
.
makeweak
(
t
)
200
if
not
t
then
201
t
=
{
}
202
end
203
local
m
=
getmetatable
(
t
)
204
if
m
then
205
m
.
__mode
=
"
v
"
206
else
207
setmetatable
(
t
,
{
__mode
=
"
v
"
}
)
208
end
209
return
t
210
end
211 212
-- Problem: we have no __next (which is ok as it would probably slow down lua) so
213
-- we cannot loop over the keys.
214 215
-- local parametersets = table.autokeys()
216
--
217
-- parametersets.foo.bar = function(t,k) return "OEPS" end
218
-- parametersets.foo.foo = "SPEO"
219
-- parametersets.crap = { a = "a", b = table.autokey { function() return "b" end } }
220
--
221
-- print(parametersets.foo.bar)
222
-- print(parametersets.foo.foo)
223
-- print(parametersets.crap.b)
224
-- print(parametersets.crap.b[1])
225 226
-- function table.autotables(t)
227
-- local t = t or { }
228
-- local m = getmetatable(t)
229
-- if not m then
230
-- m = { }
231
-- setmetatable(t,m)
232
-- end
233
-- m.__newindex = function(t,k,p)
234
-- local v = { }
235
-- local m = {
236
-- __index = function(t,k)
237
-- local v = p[k]
238
-- if type(v) == "function" then
239
-- return v(t,k) -- so we can have multiple arguments
240
-- else
241
-- return v
242
-- end
243
-- end,
244
-- __newindex = function(t,k,v)
245
-- p[k] = v
246
-- end,
247
-- __len = function(t)
248
-- return #p
249
-- end,
250
-- }
251
-- setmetatable(v,m)
252
-- rawset(t,k,v)
253
-- return v
254
-- end
255
-- m.__index = function(t,k)
256
-- local v = { }
257
-- t[k] = v -- calls newindex
258
-- return v
259
-- end
260
-- return t
261
-- end
262
--
263
-- function table.autokeys(p)
264
-- local t = { }
265
-- setmetatable(t, {
266
-- __newindex = function(t,k,v)
267
-- p[k] = v
268
-- end,
269
-- __index = function(t,k)
270
-- local v = p[k]
271
-- if type(v) == "function" then
272
-- return v(t,k) -- so we can have multiple arguments
273
-- else
274
-- return v
275
-- end
276
-- end,
277
-- __len = function(t)
278
-- return #p
279
-- end,
280
-- })
281
-- return t
282
-- end
283