func init() { gohanscript.RegisterStmtParser("split", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "value", "sep") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var value string ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(string) } var sep string isep := stmt.Arg("sep", context) if isep != nil { sep = isep.(string) } result1, err := lib.Split( value, sep) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("Split", func(vm *gohanscript.VM, args []interface{}) []interface{} { value := args[0].(string) sep := args[1].(string) result1, err := lib.Split( value, sep) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("join", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "value", "sep") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var value []interface{} ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.([]interface{}) } var sep string isep := stmt.Arg("sep", context) if isep != nil { sep = isep.(string) } result1, err := lib.Join( value, sep) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("Join", func(vm *gohanscript.VM, args []interface{}) []interface{} { value := args[0].([]interface{}) sep := args[0].(string) result1, err := lib.Join( value, sep) return []interface{}{ result1, err} }) }
func init() { gohanscript.RegisterStmtParser("http_server", httpServer) }
func init() { gohanscript.RegisterStmtParser("http_get", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var headers map[string]interface{} iheaders := stmt.Arg("headers", context) if iheaders != nil { headers = iheaders.(map[string]interface{}) } result1, err := lib.HTTPGet( url, headers) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("HTTPGet", func(vm *gohanscript.VM, args []interface{}) []interface{} { url, _ := args[0].(string) headers, _ := args[0].(map[string]interface{}) result1, err := lib.HTTPGet( url, headers) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("http_post", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var headers map[string]interface{} iheaders := stmt.Arg("headers", context) if iheaders != nil { headers = iheaders.(map[string]interface{}) } var postData map[string]interface{} ipostData := stmt.Arg("post_data", context) if ipostData != nil { postData = ipostData.(map[string]interface{}) } result1, err := lib.HTTPPost( url, headers, postData) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("HTTPPost", func(vm *gohanscript.VM, args []interface{}) []interface{} { url, _ := args[0].(string) headers, _ := args[0].(map[string]interface{}) postData, _ := args[0].(map[string]interface{}) result1, err := lib.HTTPPost( url, headers, postData) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("http_put", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var headers map[string]interface{} iheaders := stmt.Arg("headers", context) if iheaders != nil { headers = iheaders.(map[string]interface{}) } var postData map[string]interface{} ipostData := stmt.Arg("post_data", context) if ipostData != nil { postData = ipostData.(map[string]interface{}) } result1, err := lib.HTTPPut( url, headers, postData) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("HTTPPut", func(vm *gohanscript.VM, args []interface{}) []interface{} { url, _ := args[0].(string) headers, _ := args[0].(map[string]interface{}) postData, _ := args[0].(map[string]interface{}) result1, err := lib.HTTPPut( url, headers, postData) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("http_patch", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var headers map[string]interface{} iheaders := stmt.Arg("headers", context) if iheaders != nil { headers = iheaders.(map[string]interface{}) } var postData map[string]interface{} ipostData := stmt.Arg("post_data", context) if ipostData != nil { postData = ipostData.(map[string]interface{}) } result1, err := lib.HTTPPatch( url, headers, postData) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("HTTPPatch", func(vm *gohanscript.VM, args []interface{}) []interface{} { url, _ := args[0].(string) headers, _ := args[0].(map[string]interface{}) postData, _ := args[0].(map[string]interface{}) result1, err := lib.HTTPPatch( url, headers, postData) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("http_delete", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var headers map[string]interface{} iheaders := stmt.Arg("headers", context) if iheaders != nil { headers = iheaders.(map[string]interface{}) } result1, err := lib.HTTPDelete( url, headers) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("HTTPDelete", func(vm *gohanscript.VM, args []interface{}) []interface{} { url, _ := args[0].(string) headers, _ := args[0].(map[string]interface{}) result1, err := lib.HTTPDelete( url, headers) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("http_request", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var method string imethod := stmt.Arg("method", context) if imethod != nil { method = imethod.(string) } var headers map[string]interface{} iheaders := stmt.Arg("headers", context) if iheaders != nil { headers = iheaders.(map[string]interface{}) } var postData map[string]interface{} ipostData := stmt.Arg("post_data", context) if ipostData != nil { postData = ipostData.(map[string]interface{}) } result1, err := lib.HTTPRequest( url, method, headers, postData) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("HTTPRequest", func(vm *gohanscript.VM, args []interface{}) []interface{} { url, _ := args[0].(string) method, _ := args[0].(string) headers, _ := args[0].(map[string]interface{}) postData, _ := args[0].(map[string]interface{}) result1, err := lib.HTTPRequest( url, method, headers, postData) return []interface{}{ result1, err} }) }
func init() { gohanscript.RegisterStmtParser("job", backgroundJob) }
func init() { gohanscript.RegisterStmtParser("fetch_content", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var path string ipath := stmt.Arg("path", context) if ipath != nil { path = ipath.(string) } result1, err := lib.FetchContent( path) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("FetchContent", func(vm *gohanscript.VM, args []interface{}) []interface{} { path, _ := args[0].(string) result1, err := lib.FetchContent( path) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("save_content", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var path string ipath := stmt.Arg("path", context) if ipath != nil { path = ipath.(string) } var data interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(interface{}) } err := lib.SaveContent( path, data) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("SaveContent", func(vm *gohanscript.VM, args []interface{}) []interface{} { path, _ := args[0].(string) data, _ := args[0].(interface{}) err := lib.SaveContent( path, data) return []interface{}{ err} }) }
func init() { gohanscript.RegisterStmtParser("make_queue", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "workers") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var workers int iworkers := stmt.Arg("workers", context) if iworkers != nil { workers = iworkers.(int) } result1 := lib.MakeQueue( workers) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("MakeQueue", func(vm *gohanscript.VM, args []interface{}) []interface{} { workers := args[0].(int) result1 := lib.MakeQueue( workers) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("wait_queue", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "queue") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var queue *job.Queue iqueue := stmt.Arg("queue", context) if iqueue != nil { queue = iqueue.(*job.Queue) } lib.WaitQueue( queue) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("WaitQueue", func(vm *gohanscript.VM, args []interface{}) []interface{} { queue := args[0].(*job.Queue) lib.WaitQueue( queue) return nil }) gohanscript.RegisterStmtParser("stop", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "queue") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var queue *job.Queue iqueue := stmt.Arg("queue", context) if iqueue != nil { queue = iqueue.(*job.Queue) } lib.Stop( queue) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("Stop", func(vm *gohanscript.VM, args []interface{}) []interface{} { queue := args[0].(*job.Queue) lib.Stop( queue) return nil }) gohanscript.RegisterStmtParser("force_stop", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "queue") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var queue *job.Queue iqueue := stmt.Arg("queue", context) if iqueue != nil { queue = iqueue.(*job.Queue) } lib.ForceStop( queue) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("ForceStop", func(vm *gohanscript.VM, args []interface{}) []interface{} { queue := args[0].(*job.Queue) lib.ForceStop( queue) return nil }) }
func init() { gohanscript.RegisterStmtParser("make_map", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { result1 := lib.MakeMap() return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("MakeMap", func(vm *gohanscript.VM, args []interface{}) []interface{} { result1 := lib.MakeMap() return []interface{}{ result1} }) gohanscript.RegisterStmtParser("map_set", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var m cmap.ConcurrentMap im := stmt.Arg("m", context) if im != nil { m = im.(cmap.ConcurrentMap) } var key string ikey := stmt.Arg("key", context) if ikey != nil { key = ikey.(string) } var value interface{} ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(interface{}) } lib.MapSet( m, key, value) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("MapSet", func(vm *gohanscript.VM, args []interface{}) []interface{} { m, _ := args[0].(cmap.ConcurrentMap) key, _ := args[0].(string) value, _ := args[0].(interface{}) lib.MapSet( m, key, value) return nil }) gohanscript.RegisterStmtParser("map_get", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var m cmap.ConcurrentMap im := stmt.Arg("m", context) if im != nil { m = im.(cmap.ConcurrentMap) } var key string ikey := stmt.Arg("key", context) if ikey != nil { key = ikey.(string) } result1 := lib.MapGet( m, key) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("MapGet", func(vm *gohanscript.VM, args []interface{}) []interface{} { m, _ := args[0].(cmap.ConcurrentMap) key, _ := args[0].(string) result1 := lib.MapGet( m, key) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("map_has", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var m cmap.ConcurrentMap im := stmt.Arg("m", context) if im != nil { m = im.(cmap.ConcurrentMap) } var key string ikey := stmt.Arg("key", context) if ikey != nil { key = ikey.(string) } result1 := lib.MapHas( m, key) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("MapHas", func(vm *gohanscript.VM, args []interface{}) []interface{} { m, _ := args[0].(cmap.ConcurrentMap) key, _ := args[0].(string) result1 := lib.MapHas( m, key) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("map_remove", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var m cmap.ConcurrentMap im := stmt.Arg("m", context) if im != nil { m = im.(cmap.ConcurrentMap) } var key string ikey := stmt.Arg("key", context) if ikey != nil { key = ikey.(string) } lib.MapRemove( m, key) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("MapRemove", func(vm *gohanscript.VM, args []interface{}) []interface{} { m, _ := args[0].(cmap.ConcurrentMap) key, _ := args[0].(string) lib.MapRemove( m, key) return nil }) gohanscript.RegisterStmtParser("make_counter", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var value int ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(int) } result1 := lib.MakeCounter( value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("MakeCounter", func(vm *gohanscript.VM, args []interface{}) []interface{} { value, _ := args[0].(int) result1 := lib.MakeCounter( value) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("counter_add", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var counter *util.Counter icounter := stmt.Arg("counter", context) if icounter != nil { counter = icounter.(*util.Counter) } var value int ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(int) } lib.CounterAdd( counter, value) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("CounterAdd", func(vm *gohanscript.VM, args []interface{}) []interface{} { counter, _ := args[0].(*util.Counter) value, _ := args[0].(int) lib.CounterAdd( counter, value) return nil }) gohanscript.RegisterStmtParser("counter_value", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var counter *util.Counter icounter := stmt.Arg("counter", context) if icounter != nil { counter = icounter.(*util.Counter) } result1 := lib.CounterValue( counter) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("CounterValue", func(vm *gohanscript.VM, args []interface{}) []interface{} { counter, _ := args[0].(*util.Counter) result1 := lib.CounterValue( counter) return []interface{}{ result1} }) }
func init() { gohanscript.RegisterStmtParser("uuid", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { result1 := lib.UUID() return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("UUID", func(vm *gohanscript.VM, args []interface{}) []interface{} { result1 := lib.UUID() return []interface{}{ result1} }) gohanscript.RegisterStmtParser("format_uuid", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var uuid string iuuid := stmt.Arg("uuid", context) if iuuid != nil { uuid = iuuid.(string) } result1, err := lib.FormatUUID( uuid) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("FormatUUID", func(vm *gohanscript.VM, args []interface{}) []interface{} { uuid, _ := args[0].(string) result1, err := lib.FormatUUID( uuid) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("env", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { result1 := lib.Env() return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Env", func(vm *gohanscript.VM, args []interface{}) []interface{} { result1 := lib.Env() return []interface{}{ result1} }) gohanscript.RegisterStmtParser("normalize_map", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var data map[string]interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(map[string]interface{}) } result1 := lib.NormalizeMap( data) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("NormalizeMap", func(vm *gohanscript.VM, args []interface{}) []interface{} { data, _ := args[0].(map[string]interface{}) result1 := lib.NormalizeMap( data) return []interface{}{ result1} }) }
func init() { gohanscript.RegisterStmtParser("get_test_server_url", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "server") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var server *httptest.Server iserver := stmt.Arg("server", context) if iserver != nil { server = iserver.(*httptest.Server) } result1 := lib.GetTestServerURL( server) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("GetTestServerURL", func(vm *gohanscript.VM, args []interface{}) []interface{} { server := args[0].(*httptest.Server) result1 := lib.GetTestServerURL( server) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("stop_test_server", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "server") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var server *httptest.Server iserver := stmt.Arg("server", context) if iserver != nil { server = iserver.(*httptest.Server) } lib.StopTestServer( server) return nil, nil }, nil }) gohanscript.RegisterMiniGoFunc("StopTestServer", func(vm *gohanscript.VM, args []interface{}) []interface{} { server := args[0].(*httptest.Server) lib.StopTestServer( server) return nil }) gohanscript.RegisterStmtParser("gohan_server", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "config_file", "test") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var configFile string iconfigFile := stmt.Arg("config_file", context) if iconfigFile != nil { configFile = iconfigFile.(string) } var test bool itest := stmt.Arg("test", context) if itest != nil { test = itest.(bool) } result1, err := lib.GohanServer( configFile, test) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("GohanServer", func(vm *gohanscript.VM, args []interface{}) []interface{} { configFile := args[0].(string) test := args[0].(bool) result1, err := lib.GohanServer( configFile, test) return []interface{}{ result1, err} }) }
func init() { gohanscript.RegisterStmtParser("ip_to_int", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "ip") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var ip string iip := stmt.Arg("ip", context) if iip != nil { ip = iip.(string) } result1 := lib.IPToInt( ip) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("IPToInt", func(vm *gohanscript.VM, args []interface{}) []interface{} { ip := args[0].(string) result1 := lib.IPToInt( ip) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("int_to_ip", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "value") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var value int ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(int) } result1 := lib.IntToIP( value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("IntToIP", func(vm *gohanscript.VM, args []interface{}) []interface{} { value := args[0].(int) result1 := lib.IntToIP( value) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("ip_add", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "ip", "value") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var ip string iip := stmt.Arg("ip", context) if iip != nil { ip = iip.(string) } var value int ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(int) } result1 := lib.IPAdd( ip, value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("IPAdd", func(vm *gohanscript.VM, args []interface{}) []interface{} { ip := args[0].(string) value := args[0].(int) result1 := lib.IPAdd( ip, value) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("parse_cidr", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "cidr") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var cidr string icidr := stmt.Arg("cidr", context) if icidr != nil { cidr = icidr.(string) } result1, result2, result3 := lib.ParseCidr( cidr) return []interface{}{ result1, result2, result3}, nil }, nil }) gohanscript.RegisterMiniGoFunc("ParseCidr", func(vm *gohanscript.VM, args []interface{}) []interface{} { cidr := args[0].(string) result1, result2, result3 := lib.ParseCidr( cidr) return []interface{}{ result1, result2, result3} }) gohanscript.RegisterStmtParser("float_to_int", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "value") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var value float64 ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(float64) } result1 := lib.FloatToInt( value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("FloatToInt", func(vm *gohanscript.VM, args []interface{}) []interface{} { value := args[0].(float64) result1 := lib.FloatToInt( value) return []interface{}{ result1} }) }
func init() { gohanscript.RegisterStmtParser("gohan_schema", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } result1, err := lib.GohanSchema( schemaID) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("GohanSchema", func(vm *gohanscript.VM, args []interface{}) []interface{} { schemaID, _ := args[0].(string) result1, err := lib.GohanSchema( schemaID) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("gohan_schemas", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { result1 := lib.GohanSchemas() return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("GohanSchemas", func(vm *gohanscript.VM, args []interface{}) []interface{} { result1 := lib.GohanSchemas() return []interface{}{ result1} }) gohanscript.RegisterStmtParser("gohan_policies", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { result1 := lib.GohanPolicies() return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("GohanPolicies", func(vm *gohanscript.VM, args []interface{}) []interface{} { result1 := lib.GohanPolicies() return []interface{}{ result1} }) gohanscript.RegisterStmtParser("read_config", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var path string ipath := stmt.Arg("path", context) if ipath != nil { path = ipath.(string) } err := lib.ReadConfig( path) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("ReadConfig", func(vm *gohanscript.VM, args []interface{}) []interface{} { path, _ := args[0].(string) err := lib.ReadConfig( path) return []interface{}{ err} }) gohanscript.RegisterStmtParser("get_config", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var key string ikey := stmt.Arg("key", context) if ikey != nil { key = ikey.(string) } var defaultValue interface{} idefaultValue := stmt.Arg("default_value", context) if idefaultValue != nil { defaultValue = idefaultValue.(interface{}) } result1 := lib.GetConfig( key, defaultValue) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("GetConfig", func(vm *gohanscript.VM, args []interface{}) []interface{} { key, _ := args[0].(string) defaultValue, _ := args[0].(interface{}) result1 := lib.GetConfig( key, defaultValue) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("gohan_load_schema", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var src string isrc := stmt.Arg("src", context) if isrc != nil { src = isrc.(string) } result1, err := lib.GohanLoadSchema( src) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("GohanLoadSchema", func(vm *gohanscript.VM, args []interface{}) []interface{} { src, _ := args[0].(string) result1, err := lib.GohanLoadSchema( src) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("connect_db", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var dbType string idbType := stmt.Arg("db_type", context) if idbType != nil { dbType = idbType.(string) } var connection string iconnection := stmt.Arg("connection", context) if iconnection != nil { connection = iconnection.(string) } var maxOpenConn int imaxOpenConn := stmt.Arg("max_open_conn", context) if imaxOpenConn != nil { maxOpenConn = imaxOpenConn.(int) } result1, err := lib.ConnectDB( dbType, connection, maxOpenConn) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("ConnectDB", func(vm *gohanscript.VM, args []interface{}) []interface{} { dbType, _ := args[0].(string) connection, _ := args[0].(string) maxOpenConn, _ := args[0].(int) result1, err := lib.ConnectDB( dbType, connection, maxOpenConn) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("init_db", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var dbType string idbType := stmt.Arg("db_type", context) if idbType != nil { dbType = idbType.(string) } var connection string iconnection := stmt.Arg("connection", context) if iconnection != nil { connection = iconnection.(string) } var dropOnCreate bool idropOnCreate := stmt.Arg("drop_on_create", context) if idropOnCreate != nil { dropOnCreate = idropOnCreate.(bool) } var cascade bool icascade := stmt.Arg("cascade", context) if icascade != nil { cascade = icascade.(bool) } err := lib.InitDB( dbType, connection, dropOnCreate, cascade) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("InitDB", func(vm *gohanscript.VM, args []interface{}) []interface{} { dbType, _ := args[0].(string) connection, _ := args[0].(string) dropOnCreate, _ := args[0].(bool) cascade, _ := args[0].(bool) err := lib.InitDB( dbType, connection, dropOnCreate, cascade) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_begin", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var connection db.DB iconnection := stmt.Arg("connection", context) if iconnection != nil { connection = iconnection.(db.DB) } result1, err := lib.DBBegin( connection) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("DBBegin", func(vm *gohanscript.VM, args []interface{}) []interface{} { connection, _ := args[0].(db.DB) result1, err := lib.DBBegin( connection) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("db_commit", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } err := lib.DBCommit( tx) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("DBCommit", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) err := lib.DBCommit( tx) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_close", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } err := lib.DBClose( tx) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("DBClose", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) err := lib.DBClose( tx) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_get", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var id string iid := stmt.Arg("id", context) if iid != nil { id = iid.(string) } var tenantID string itenantID := stmt.Arg("tenant_id", context) if itenantID != nil { tenantID = itenantID.(string) } result1, err := lib.DBGet( tx, schemaID, id, tenantID) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("DBGet", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) schemaID, _ := args[0].(string) id, _ := args[0].(string) tenantID, _ := args[0].(string) result1, err := lib.DBGet( tx, schemaID, id, tenantID) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("db_create", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var data map[string]interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(map[string]interface{}) } err := lib.DBCreate( tx, schemaID, data) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("DBCreate", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) schemaID, _ := args[0].(string) data, _ := args[0].(map[string]interface{}) err := lib.DBCreate( tx, schemaID, data) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_list", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var filter map[string]interface{} ifilter := stmt.Arg("filter", context) if ifilter != nil { filter = ifilter.(map[string]interface{}) } result1, err := lib.DBList( tx, schemaID, filter) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("DBList", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) schemaID, _ := args[0].(string) filter, _ := args[0].(map[string]interface{}) result1, err := lib.DBList( tx, schemaID, filter) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("db_update", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var data map[string]interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(map[string]interface{}) } err := lib.DBUpdate( tx, schemaID, data) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("DBUpdate", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) schemaID, _ := args[0].(string) data, _ := args[0].(map[string]interface{}) err := lib.DBUpdate( tx, schemaID, data) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_delete", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var id string iid := stmt.Arg("id", context) if iid != nil { id = iid.(string) } err := lib.DBDelete( tx, schemaID, id) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("DBDelete", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) schemaID, _ := args[0].(string) id, _ := args[0].(string) err := lib.DBDelete( tx, schemaID, id) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_query", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var sql string isql := stmt.Arg("sql", context) if isql != nil { sql = isql.(string) } var arguments []interface{} iarguments := stmt.Arg("arguments", context) if iarguments != nil { arguments = iarguments.([]interface{}) } result1, err := lib.DBQuery( tx, schemaID, sql, arguments) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("DBQuery", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) schemaID, _ := args[0].(string) sql, _ := args[0].(string) arguments, _ := args[0].([]interface{}) result1, err := lib.DBQuery( tx, schemaID, sql, arguments) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("db_exec", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var tx transaction.Transaction itx := stmt.Arg("tx", context) if itx != nil { tx = itx.(transaction.Transaction) } var sql string isql := stmt.Arg("sql", context) if isql != nil { sql = isql.(string) } var arguments []interface{} iarguments := stmt.Arg("arguments", context) if iarguments != nil { arguments = iarguments.([]interface{}) } err := lib.DBExec( tx, sql, arguments) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("DBExec", func(vm *gohanscript.VM, args []interface{}) []interface{} { tx, _ := args[0].(transaction.Transaction) sql, _ := args[0].(string) arguments, _ := args[0].([]interface{}) err := lib.DBExec( tx, sql, arguments) return []interface{}{ err} }) gohanscript.RegisterStmtParser("db_column", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var schemaID string ischemaID := stmt.Arg("schema_id", context) if ischemaID != nil { schemaID = ischemaID.(string) } var join bool ijoin := stmt.Arg("join", context) if ijoin != nil { join = ijoin.(bool) } result1, err := lib.DBColumn( schemaID, join) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("DBColumn", func(vm *gohanscript.VM, args []interface{}) []interface{} { schemaID, _ := args[0].(string) join, _ := args[0].(bool) result1, err := lib.DBColumn( schemaID, join) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("error", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var code int icode := stmt.Arg("code", context) if icode != nil { code = icode.(int) } var name string iname := stmt.Arg("name", context) if iname != nil { name = iname.(string) } var message string imessage := stmt.Arg("message", context) if imessage != nil { message = imessage.(string) } err := lib.Error( code, name, message) return nil, err }, nil }) gohanscript.RegisterMiniGoFunc("Error", func(vm *gohanscript.VM, args []interface{}) []interface{} { code, _ := args[0].(int) name, _ := args[0].(string) message, _ := args[1].(string) err := lib.Error( code, name, message) return []interface{}{ err} }) }
func init() { gohanscript.RegisterStmtParser("get_openstack_client", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "auth_url", "user_name", "password", "domain_name", "tenant_name", "version") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var authURL string iauthURL := stmt.Arg("auth_url", context) if iauthURL != nil { authURL = iauthURL.(string) } var userName string iuserName := stmt.Arg("user_name", context) if iuserName != nil { userName = iuserName.(string) } var password string ipassword := stmt.Arg("password", context) if ipassword != nil { password = ipassword.(string) } var domainName string idomainName := stmt.Arg("domain_name", context) if idomainName != nil { domainName = idomainName.(string) } var tenantName string itenantName := stmt.Arg("tenant_name", context) if itenantName != nil { tenantName = itenantName.(string) } var version string iversion := stmt.Arg("version", context) if iversion != nil { version = iversion.(string) } result1, err := lib.GetOpenstackClient( authURL, userName, password, domainName, tenantName, version) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("GetOpenstackClient", func(vm *gohanscript.VM, args []interface{}) []interface{} { authURL := args[0].(string) userName := args[1].(string) password := args[2].(string) domainName := args[3].(string) tenantName := args[4].(string) version := args[5].(string) result1, err := lib.GetOpenstackClient( authURL, userName, password, domainName, tenantName, version) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("openstack_token", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } result1 := lib.OpenstackToken( client) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackToken", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) result1 := lib.OpenstackToken( client) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("openstack_get", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client", "url") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } result1, err := lib.OpenstackGet( client, url) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackGet", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) url := args[0].(string) result1, err := lib.OpenstackGet( client, url) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("openstack_ensure", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client", "url", "post_url", "data") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var postURL string ipostURL := stmt.Arg("post_url", context) if ipostURL != nil { postURL = ipostURL.(string) } var data interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(interface{}) } result1, err := lib.OpenstackEnsure( client, url, postURL, data) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackEnsure", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) url := args[0].(string) postURL := args[0].(string) data := args[0].(interface{}) result1, err := lib.OpenstackEnsure( client, url, postURL, data) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("openstack_put", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client", "url", "data") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var data interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(interface{}) } result1, err := lib.OpenstackPut( client, url, data) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackPut", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) url := args[0].(string) data := args[0].(interface{}) result1, err := lib.OpenstackPut( client, url, data) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("openstack_post", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client", "url", "data") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } var data interface{} idata := stmt.Arg("data", context) if idata != nil { data = idata.(interface{}) } result1, err := lib.OpenstackPost( client, url, data) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackPost", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) url := args[0].(string) data := args[0].(interface{}) result1, err := lib.OpenstackPost( client, url, data) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("openstack_delete", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client", "url") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } var url string iurl := stmt.Arg("url", context) if iurl != nil { url = iurl.(string) } result1, err := lib.OpenstackDelete( client, url) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackDelete", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) url := args[0].(string) result1, err := lib.OpenstackDelete( client, url) return []interface{}{ result1, err} }) gohanscript.RegisterStmtParser("openstack_endpoint", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "client", "endpoint_type", "name", "region", "availability") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var client *gophercloud.ServiceClient iclient := stmt.Arg("client", context) if iclient != nil { client = iclient.(*gophercloud.ServiceClient) } var endpointType string iendpointType := stmt.Arg("endpoint_type", context) if iendpointType != nil { endpointType = iendpointType.(string) } var name string iname := stmt.Arg("name", context) if iname != nil { name = iname.(string) } var region string iregion := stmt.Arg("region", context) if iregion != nil { region = iregion.(string) } var availability string iavailability := stmt.Arg("availability", context) if iavailability != nil { availability = iavailability.(string) } result1, err := lib.OpenstackEndpoint( client, endpointType, name, region, availability) return result1, err }, nil }) gohanscript.RegisterMiniGoFunc("OpenstackEndpoint", func(vm *gohanscript.VM, args []interface{}) []interface{} { client := args[0].(*gophercloud.ServiceClient) endpointType := args[0].(string) name := args[1].(string) region := args[2].(string) availability := args[3].(string) result1, err := lib.OpenstackEndpoint( client, endpointType, name, region, availability) return []interface{}{ result1, err} }) }
func init() { gohanscript.RegisterStmtParser("transaction", transactionFunc) }
func init() { gohanscript.RegisterStmtParser("add_int", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var a int ia := stmt.Arg("a", context) if ia != nil { a = ia.(int) } var b int ib := stmt.Arg("b", context) if ib != nil { b = ib.(int) } result1 := lib.AddInt( a, b) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("AddInt", func(vm *gohanscript.VM, args []interface{}) []interface{} { a, _ := args[0].(int) b, _ := args[1].(int) result1 := lib.AddInt( a, b) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("sub_int", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var a int ia := stmt.Arg("a", context) if ia != nil { a = ia.(int) } var b int ib := stmt.Arg("b", context) if ib != nil { b = ib.(int) } result1 := lib.SubInt( a, b) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("SubInt", func(vm *gohanscript.VM, args []interface{}) []interface{} { a, _ := args[0].(int) b, _ := args[1].(int) result1 := lib.SubInt( a, b) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("mul_int", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var a int ia := stmt.Arg("a", context) if ia != nil { a = ia.(int) } var b int ib := stmt.Arg("b", context) if ib != nil { b = ib.(int) } result1 := lib.MulInt( a, b) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("MulInt", func(vm *gohanscript.VM, args []interface{}) []interface{} { a, _ := args[0].(int) b, _ := args[1].(int) result1 := lib.MulInt( a, b) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("div_int", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { return func(context *gohanscript.Context) (interface{}, error) { var a int ia := stmt.Arg("a", context) if ia != nil { a = ia.(int) } var b int ib := stmt.Arg("b", context) if ib != nil { b = ib.(int) } result1 := lib.DivInt( a, b) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("DivInt", func(vm *gohanscript.VM, args []interface{}) []interface{} { a, _ := args[0].(int) b, _ := args[1].(int) result1 := lib.DivInt( a, b) return []interface{}{ result1} }) }
func init() { gohanscript.RegisterStmtParser("command", command) }
func init() { gohanscript.RegisterStmtParser("append", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list", "value") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } var value interface{} ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(interface{}) } result1 := lib.Append( list, value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Append", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) value := args[0].(interface{}) result1 := lib.Append( list, value) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("contains", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list", "value") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } var value interface{} ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(interface{}) } result1 := lib.Contains( list, value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Contains", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) value := args[0].(interface{}) result1 := lib.Contains( list, value) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("size", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } result1 := lib.Size( list) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Size", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) result1 := lib.Size( list) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("shift", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } result1, result2 := lib.Shift( list) return []interface{}{ result1, result2}, nil }, nil }) gohanscript.RegisterMiniGoFunc("Shift", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) result1, result2 := lib.Shift( list) return []interface{}{ result1, result2} }) gohanscript.RegisterStmtParser("unshift", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list", "value") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } var value interface{} ivalue := stmt.Arg("value", context) if ivalue != nil { value = ivalue.(interface{}) } result1 := lib.Unshift( list, value) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Unshift", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) value := args[0].(interface{}) result1 := lib.Unshift( list, value) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("copy", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } result1 := lib.Copy( list) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Copy", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) result1 := lib.Copy( list) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("delete", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list", "index") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } var index int iindex := stmt.Arg("index", context) if iindex != nil { index = iindex.(int) } result1 := lib.Delete( list, index) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Delete", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) index := args[0].(int) result1 := lib.Delete( list, index) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("first", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } result1 := lib.First( list) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("First", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) result1 := lib.First( list) return []interface{}{ result1} }) gohanscript.RegisterStmtParser("last", func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { stmtErr := stmt.HasArgs( "list") if stmtErr != nil { return nil, stmtErr } return func(context *gohanscript.Context) (interface{}, error) { var list []interface{} ilist := stmt.Arg("list", context) if ilist != nil { list = ilist.([]interface{}) } result1 := lib.Last( list) return result1, nil }, nil }) gohanscript.RegisterMiniGoFunc("Last", func(vm *gohanscript.VM, args []interface{}) []interface{} { list := args[0].([]interface{}) result1 := lib.Last( list) return []interface{}{ result1} }) }