func MessThingTellallMethod(state *lua.State, thing *Thing) int {
state.PushGoFunction(func(state *lua.State) int {
place := checkThing(state, 1)
text := state.CheckString(2)
// If arg 3 is present, it should be a table of Things to exclude.
excludes := make(map[ThingId]bool)
if 2 < state.GetTop() {
if !state.IsTable(3) {
state.ArgError(3, "expected `table` for exclude argument if present")
}
numExcludes := int(state.ObjLen(3))
for i := 0; i < numExcludes; i++ {
state.RawGeti(3, i+1)
exclude := checkThing(state, -1)
excludes[exclude.Id] = true
}
}
for _, content := range place.GetContents() {
if excludes[content.Id] {
continue
}
if content.Client != nil {
content.Client.Send(text)
}
}
return 0
})
return 1
}
// return the Lua table at 'idx' as a copied Go slice. If 't' is nil then the slice
// type is []interface{}
func CopyTableToSlice(L *lua.State, t reflect.Type, idx int) interface{} {
if t == nil {
t = reflect.TypeOf(tslice)
}
te := t.Elem()
n := int(L.ObjLen(idx))
slice := reflect.MakeSlice(t, n, n)
for i := 1; i <= n; i++ {
L.RawGeti(idx, i)
val := LuaToGo(L, te, -1)
slice.Index(i - 1).Set(valueOf(val))
L.Pop(1)
}
return slice.Interface()
}
// Also for arrays.
func copyTableToSlice(L *lua.State, t reflect.Type, idx int, visited map[uintptr]interface{}) interface{} {
if t == nil {
t = tslice
}
ref := t
// There is probably no point at accepting more than one level of dreference.
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
n := int(L.ObjLen(idx))
var slice reflect.Value
if t.Kind() == reflect.Array {
slice = reflect.New(t)
slice = slice.Elem()
} else {
slice = reflect.MakeSlice(t, n, n)
}
// Do not add empty slices to the list of visited elements.
// The empty Lua table is a single instance object and gets re-used across maps, slices and others.
if n > 0 {
ptr := L.ToPointer(idx)
if ref.Kind() == reflect.Ptr {
visited[ptr] = slice.Addr().Interface()
} else {
visited[ptr] = slice.Interface()
}
}
te := t.Elem()
for i := 1; i <= n; i++ {
L.RawGeti(idx, i)
val := reflect.ValueOf(luaToGo(L, te, -1, visited))
if val.Interface() == nullv.Interface() {
val = reflect.Zero(te)
}
slice.Index(i - 1).Set(val)
L.Pop(1)
}
if ref.Kind() == reflect.Ptr {
return slice.Addr().Interface()
}
return slice.Interface()
}
// Return the Lua table at 'idx' as a copied Go slice. If 't' is nil then the slice
// type is []interface{}
func CopyTableToSlice(L *lua.State, t reflect.Type, idx int) interface{} {
if t == nil {
t = tslice
}
te := t.Elem()
n := int(L.ObjLen(idx))
slice := reflect.MakeSlice(t, n, n)
for i := 1; i <= n; i++ {
L.RawGeti(idx, i)
val := luaToGoValue(L, te, -1)
if val == nullv {
val = reflect.Zero(te)
}
slice.Index(i - 1).Set(val)
L.Pop(1)
}
return slice.Interface()
}
func TableFormat(state *lua.State) int {
state.CheckType(1, lua.LUA_TTABLE)
state.CheckType(2, lua.LUA_TTABLE) // ( ??? -- tbl tblFields )
log.Println("Formatting a table by a table")
printStackTypes(state)
numFields := int(state.ObjLen(-1))
fields := make([]string, numFields)
maxFieldLen := make(map[string]int)
for i := 0; i < numFields; i++ {
state.RawGeti(-1, i+1) // ( tbl tblFields -- tbl tblFields strHeader )
fieldName := state.ToString(-1)
fields[i] = fieldName
maxFieldLen[fieldName] = len(fieldName)
state.Pop(1) // ( tbl tblFields strField -- tbl tblFields )
}
state.Pop(1) // ( tbl tblFields -- tbl )
log.Println("Slurped up the fields list (table #2)")
printStackTypes(state)
numRows := int(state.ObjLen(-1))
rows := make([]map[string]string, numRows)
for i := 0; i < numRows; i++ {
state.RawGeti(-1, i+1) // ( tbl -- tbl tblRow )
row := make(map[string]string)
for _, field := range fields {
state.PushString(field) // ( tbl tblRow -- tbl tblRow strField )
state.RawGet(-2) // ( tbl tblRow strField -- tbl tblRow tblField )
row[field] = state.ToString(-1)
if maxFieldLen[field] < len(row[field]) {
maxFieldLen[field] = len(row[field])
}
state.Pop(1) // ( tbl tblRow tblField -- tbl tblRow )
}
rows[i] = row
state.Pop(1) // ( tbl tblRow -- tbl )
}
state.Pop(1) // ( tbl -- )
log.Println("Slurped up the data table (table #1)")
printStackTypes(state)
// %5s %10s %13s
fmtStrings := make([]string, numFields)
for i, field := range fields {
fmtStrings[i] = fmt.Sprintf("%%-%ds", maxFieldLen[field])
}
fmtString := strings.Join(fmtStrings, " ")
log.Println("Figured out the format string:", fmtString)
rowStrings := make([]string, numRows+1)
rowFields := make([]interface{}, numFields)
for i, row := range rows {
for j, field := range fields {
rowFields[j] = row[field]
}
rowStrings[i+1] = fmt.Sprintf(fmtString, rowFields...)
}
for i := 0; i < numFields; i++ {
rowFields[i] = strings.Title(fields[i])
}
rowStrings[0] = fmt.Sprintf(fmtString, rowFields...)
log.Println("Yay formatted all the strings")
formattedTable := strings.Join(rowStrings, "\n")
state.PushString(formattedTable) // ( -- str )
log.Println("All done formatting this table!")
printStackTypes(state)
return 1
}
