src/foundation/api/apiserver/app/tmp/run/run.go

   1 // GENERATED CODE - DO NOT EDIT
   2 // This file is the run file for Revel.
   3 // It registers all the controllers and provides details for the Revel server engine to
   4 // properly inject parameters directly into the action endpoints.
   5 package run
   6
   7 import (
   8         "reflect"
   9         "github.com/revel/revel"
  10         _ "apiserver/app"
  11         controllers "apiserver/app/controllers"
  12         tests "apiserver/tests"
  13         controllers0 "github.com/revel/modules/static/app/controllers"
  14         _ "github.com/revel/modules/testrunner/app"
  15         controllers1 "github.com/revel/modules/testrunner/app/controllers"
  16         "github.com/revel/revel/testing"
  17 )
  18
  19 var (
  20         // So compiler won't complain if the generated code doesn't reference reflect package...
  21         _ = reflect.Invalid
  22 )
  23
  24 // Register and run the application
  25 func Run(port int) {
  26         Register()
  27         revel.Run(port)
  28 }
  29
  30 // Register all the controllers
  31 func Register() {
  32         revel.AppLog.Info("Running revel server")
  33
  34         revel.RegisterController((*controllers.App)(nil),
  35                 []*revel.MethodType{
  36                         &revel.MethodType{
  37                                 Name: "Index",
  38                                 Args: []*revel.MethodArg{
  39                                 },
  40                                 RenderArgNames: map[int][]string{
  41                                         12: []string{
  42                                         },
  43                                 },
  44                         },
  45                         &revel.MethodType{
  46                                 Name: "GetStatus",
  47                                 Args: []*revel.MethodArg{
  48                                 },
  49                                 RenderArgNames: map[int][]string{
  50                                 },
  51                         },
  52
  53                 })
  54
  55         revel.RegisterController((*controllers0.Static)(nil),
  56                 []*revel.MethodType{
  57                         &revel.MethodType{
  58                                 Name: "Serve",
  59                                 Args: []*revel.MethodArg{
  60                                         &revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil)) },
  61                                         &revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil)) },
  62                                 },
  63                                 RenderArgNames: map[int][]string{
  64                                 },
  65                         },
  66                         &revel.MethodType{
  67                                 Name: "ServeDir",
  68                                 Args: []*revel.MethodArg{
  69                                         &revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil)) },
  70                                         &revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil)) },
  71                                 },
  72                                 RenderArgNames: map[int][]string{
  73                                 },
  74                         },
  75                         &revel.MethodType{
  76                                 Name: "ServeModule",
  77                                 Args: []*revel.MethodArg{
  78                                         &revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil)) },
  79                                         &revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil)) },
  80                                         &revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil)) },
  81                                 },
  82                                 RenderArgNames: map[int][]string{
  83                                 },
  84                         },
  85                         &revel.MethodType{
  86                                 Name: "ServeModuleDir",
  87                                 Args: []*revel.MethodArg{
  88                                         &revel.MethodArg{Name: "moduleName", Type: reflect.TypeOf((*string)(nil)) },
  89                                         &revel.MethodArg{Name: "prefix", Type: reflect.TypeOf((*string)(nil)) },
  90                                         &revel.MethodArg{Name: "filepath", Type: reflect.TypeOf((*string)(nil)) },
  91                                 },
  92                                 RenderArgNames: map[int][]string{
  93                                 },
  94                         },
  95
  96                 })
  97
  98         revel.RegisterController((*controllers1.TestRunner)(nil),
  99                 []*revel.MethodType{
 100                         &revel.MethodType{
 101                                 Name: "Index",
 102                                 Args: []*revel.MethodArg{
 103                                 },
 104                                 RenderArgNames: map[int][]string{
 105                                         76: []string{
 106                                                 "testSuites",
 107                                         },
 108                                 },
 109                         },
 110                         &revel.MethodType{
 111                                 Name: "Suite",
 112                                 Args: []*revel.MethodArg{
 113                                         &revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil)) },
 114                                 },
 115                                 RenderArgNames: map[int][]string{
 116                                 },
 117                         },
 118                         &revel.MethodType{
 119                                 Name: "Run",
 120                                 Args: []*revel.MethodArg{
 121                                         &revel.MethodArg{Name: "suite", Type: reflect.TypeOf((*string)(nil)) },
 122                                         &revel.MethodArg{Name: "test", Type: reflect.TypeOf((*string)(nil)) },
 123                                 },
 124                                 RenderArgNames: map[int][]string{
 125                                         125: []string{
 126                                         },
 127                                 },
 128                         },
 129                         &revel.MethodType{
 130                                 Name: "List",
 131                                 Args: []*revel.MethodArg{
 132                                 },
 133                                 RenderArgNames: map[int][]string{
 134                                 },
 135                         },
 136
 137                 })
 138
 139         revel.DefaultValidationKeys = map[string]map[int]string{
 140         }
 141         testing.TestSuites = []interface{}{
 142                 (*tests.AppTest)(nil),
 143         }
 144 }