github.com/mmatczuk/gohan@v0.0.0-20170206152520-30e45d9bdb69/extension/gohanscript/autogen/lib_list.go (about) 1 package autogen 2 3 // AUTO GENERATED CODE DO NOT MODIFY MANUALLY 4 import ( 5 "github.com/cloudwan/gohan/extension/gohanscript" 6 "github.com/cloudwan/gohan/extension/gohanscript/lib" 7 ) 8 9 func init() { 10 11 gohanscript.RegisterStmtParser("append", 12 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 13 return func(context *gohanscript.Context) (interface{}, error) { 14 15 var list []interface{} 16 ilist := stmt.Arg("list", context) 17 if ilist != nil { 18 list = ilist.([]interface{}) 19 } 20 var value interface{} 21 ivalue := stmt.Arg("value", context) 22 if ivalue != nil { 23 value = ivalue.(interface{}) 24 } 25 26 result1 := 27 lib.Append( 28 list, value) 29 30 return result1, nil 31 32 }, nil 33 }) 34 gohanscript.RegisterMiniGoFunc("Append", 35 func(vm *gohanscript.VM, args []interface{}) []interface{} { 36 37 list, _ := args[0].([]interface{}) 38 value, _ := args[0].(interface{}) 39 40 result1 := 41 lib.Append( 42 list, value) 43 return []interface{}{ 44 result1} 45 46 }) 47 48 gohanscript.RegisterStmtParser("contains", 49 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 50 return func(context *gohanscript.Context) (interface{}, error) { 51 52 var list []interface{} 53 ilist := stmt.Arg("list", context) 54 if ilist != nil { 55 list = ilist.([]interface{}) 56 } 57 var value interface{} 58 ivalue := stmt.Arg("value", context) 59 if ivalue != nil { 60 value = ivalue.(interface{}) 61 } 62 63 result1 := 64 lib.Contains( 65 list, value) 66 67 return result1, nil 68 69 }, nil 70 }) 71 gohanscript.RegisterMiniGoFunc("Contains", 72 func(vm *gohanscript.VM, args []interface{}) []interface{} { 73 74 list, _ := args[0].([]interface{}) 75 value, _ := args[0].(interface{}) 76 77 result1 := 78 lib.Contains( 79 list, value) 80 return []interface{}{ 81 result1} 82 83 }) 84 85 gohanscript.RegisterStmtParser("size", 86 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 87 return func(context *gohanscript.Context) (interface{}, error) { 88 89 var list []interface{} 90 ilist := stmt.Arg("list", context) 91 if ilist != nil { 92 list = ilist.([]interface{}) 93 } 94 95 result1 := 96 lib.Size( 97 list) 98 99 return result1, nil 100 101 }, nil 102 }) 103 gohanscript.RegisterMiniGoFunc("Size", 104 func(vm *gohanscript.VM, args []interface{}) []interface{} { 105 106 list, _ := args[0].([]interface{}) 107 108 result1 := 109 lib.Size( 110 list) 111 return []interface{}{ 112 result1} 113 114 }) 115 116 gohanscript.RegisterStmtParser("shift", 117 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 118 return func(context *gohanscript.Context) (interface{}, error) { 119 120 var list []interface{} 121 ilist := stmt.Arg("list", context) 122 if ilist != nil { 123 list = ilist.([]interface{}) 124 } 125 126 result1, 127 result2 := 128 lib.Shift( 129 list) 130 131 return []interface{}{ 132 result1, 133 result2}, nil 134 135 }, nil 136 }) 137 gohanscript.RegisterMiniGoFunc("Shift", 138 func(vm *gohanscript.VM, args []interface{}) []interface{} { 139 140 list, _ := args[0].([]interface{}) 141 142 result1, 143 result2 := 144 lib.Shift( 145 list) 146 return []interface{}{ 147 result1, 148 result2} 149 150 }) 151 152 gohanscript.RegisterStmtParser("unshift", 153 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 154 return func(context *gohanscript.Context) (interface{}, error) { 155 156 var list []interface{} 157 ilist := stmt.Arg("list", context) 158 if ilist != nil { 159 list = ilist.([]interface{}) 160 } 161 var value interface{} 162 ivalue := stmt.Arg("value", context) 163 if ivalue != nil { 164 value = ivalue.(interface{}) 165 } 166 167 result1 := 168 lib.Unshift( 169 list, value) 170 171 return result1, nil 172 173 }, nil 174 }) 175 gohanscript.RegisterMiniGoFunc("Unshift", 176 func(vm *gohanscript.VM, args []interface{}) []interface{} { 177 178 list, _ := args[0].([]interface{}) 179 value, _ := args[0].(interface{}) 180 181 result1 := 182 lib.Unshift( 183 list, value) 184 return []interface{}{ 185 result1} 186 187 }) 188 189 gohanscript.RegisterStmtParser("copy", 190 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 191 return func(context *gohanscript.Context) (interface{}, error) { 192 193 var list []interface{} 194 ilist := stmt.Arg("list", context) 195 if ilist != nil { 196 list = ilist.([]interface{}) 197 } 198 199 result1 := 200 lib.Copy( 201 list) 202 203 return result1, nil 204 205 }, nil 206 }) 207 gohanscript.RegisterMiniGoFunc("Copy", 208 func(vm *gohanscript.VM, args []interface{}) []interface{} { 209 210 list, _ := args[0].([]interface{}) 211 212 result1 := 213 lib.Copy( 214 list) 215 return []interface{}{ 216 result1} 217 218 }) 219 220 gohanscript.RegisterStmtParser("delete", 221 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 222 return func(context *gohanscript.Context) (interface{}, error) { 223 224 var list []interface{} 225 ilist := stmt.Arg("list", context) 226 if ilist != nil { 227 list = ilist.([]interface{}) 228 } 229 var index int 230 iindex := stmt.Arg("index", context) 231 if iindex != nil { 232 index = iindex.(int) 233 } 234 235 result1 := 236 lib.Delete( 237 list, index) 238 239 return result1, nil 240 241 }, nil 242 }) 243 gohanscript.RegisterMiniGoFunc("Delete", 244 func(vm *gohanscript.VM, args []interface{}) []interface{} { 245 246 list, _ := args[0].([]interface{}) 247 index, _ := args[0].(int) 248 249 result1 := 250 lib.Delete( 251 list, index) 252 return []interface{}{ 253 result1} 254 255 }) 256 257 gohanscript.RegisterStmtParser("first", 258 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 259 return func(context *gohanscript.Context) (interface{}, error) { 260 261 var list []interface{} 262 ilist := stmt.Arg("list", context) 263 if ilist != nil { 264 list = ilist.([]interface{}) 265 } 266 267 result1 := 268 lib.First( 269 list) 270 271 return result1, nil 272 273 }, nil 274 }) 275 gohanscript.RegisterMiniGoFunc("First", 276 func(vm *gohanscript.VM, args []interface{}) []interface{} { 277 278 list, _ := args[0].([]interface{}) 279 280 result1 := 281 lib.First( 282 list) 283 return []interface{}{ 284 result1} 285 286 }) 287 288 gohanscript.RegisterStmtParser("last", 289 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 290 return func(context *gohanscript.Context) (interface{}, error) { 291 292 var list []interface{} 293 ilist := stmt.Arg("list", context) 294 if ilist != nil { 295 list = ilist.([]interface{}) 296 } 297 298 result1 := 299 lib.Last( 300 list) 301 302 return result1, nil 303 304 }, nil 305 }) 306 gohanscript.RegisterMiniGoFunc("Last", 307 func(vm *gohanscript.VM, args []interface{}) []interface{} { 308 309 list, _ := args[0].([]interface{}) 310 311 result1 := 312 lib.Last( 313 list) 314 return []interface{}{ 315 result1} 316 317 }) 318 319 }