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  }