libgo/go/reflect/example_test.go

   1 // Copyright 2012 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package reflect_test
   6
   7 import (
   8         "bytes"
   9         "encoding/json"
  10         "fmt"
  11         "io"
  12         "os"
  13         "reflect"
  14 )
  15
  16 func ExampleMakeFunc() {
  17         // swap is the implementation passed to MakeFunc.
  18         // It must work in terms of reflect.Values so that it is possible
  19         // to write code without knowing beforehand what the types
  20         // will be.
  21         swap := func(in []reflect.Value) []reflect.Value {
  22                 return []reflect.Value{in[1], in[0]}
  23         }
  24
  25         // makeSwap expects fptr to be a pointer to a nil function.
  26         // It sets that pointer to a new function created with MakeFunc.
  27         // When the function is invoked, reflect turns the arguments
  28         // into Values, calls swap, and then turns swap's result slice
  29         // into the values returned by the new function.
  30         makeSwap := func(fptr interface{}) {
  31                 // fptr is a pointer to a function.
  32                 // Obtain the function value itself (likely nil) as a reflect.Value
  33                 // so that we can query its type and then set the value.
  34                 fn := reflect.ValueOf(fptr).Elem()
  35
  36                 // Make a function of the right type.
  37                 v := reflect.MakeFunc(fn.Type(), swap)
  38
  39                 // Assign it to the value fn represents.
  40                 fn.Set(v)
  41         }
  42
  43         // Make and call a swap function for ints.
  44         var intSwap func(int, int) (int, int)
  45         makeSwap(&intSwap)
  46         fmt.Println(intSwap(0, 1))
  47
  48         // Make and call a swap function for float64s.
  49         var floatSwap func(float64, float64) (float64, float64)
  50         makeSwap(&floatSwap)
  51         fmt.Println(floatSwap(2.72, 3.14))
  52
  53         // Output:
  54         // 1 0
  55         // 3.14 2.72
  56 }
  57
  58 func ExampleStructTag() {
  59         type S struct {
  60                 F string `species:"gopher" color:"blue"`
  61         }
  62
  63         s := S{}
  64         st := reflect.TypeOf(s)
  65         field := st.Field(0)
  66         fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))
  67
  68         // Output:
  69         // blue gopher
  70 }
  71
  72 func ExampleStructTag_Lookup() {
  73         type S struct {
  74                 F0 string `alias:"field_0"`
  75                 F1 string `alias:""`
  76                 F2 string
  77         }
  78
  79         s := S{}
  80         st := reflect.TypeOf(s)
  81         for i := 0; i < st.NumField(); i++ {
  82                 field := st.Field(i)
  83                 if alias, ok := field.Tag.Lookup("alias"); ok {
  84                         if alias == "" {
  85                                 fmt.Println("(blank)")
  86                         } else {
  87                                 fmt.Println(alias)
  88                         }
  89                 } else {
  90                         fmt.Println("(not specified)")
  91                 }
  92         }
  93
  94         // Output:
  95         // field_0
  96         // (blank)
  97         // (not specified)
  98 }
  99
 100 func ExampleTypeOf() {
 101         // As interface types are only used for static typing, a
 102         // common idiom to find the reflection Type for an interface
 103         // type Foo is to use a *Foo value.
 104         writerType := reflect.TypeOf((*io.Writer)(nil)).Elem()
 105
 106         fileType := reflect.TypeOf((*os.File)(nil))
 107         fmt.Println(fileType.Implements(writerType))
 108
 109         // Output:
 110         // true
 111 }
 112
 113 func ExampleStructOf() {
 114         typ := reflect.StructOf([]reflect.StructField{
 115                 {
 116                         Name: "Height",
 117                         Type: reflect.TypeOf(float64(0)),
 118                         Tag:  `json:"height"`,
 119                 },
 120                 {
 121                         Name: "Age",
 122                         Type: reflect.TypeOf(int(0)),
 123                         Tag:  `json:"age"`,
 124                 },
 125         })
 126
 127         v := reflect.New(typ).Elem()
 128         v.Field(0).SetFloat(0.4)
 129         v.Field(1).SetInt(2)
 130         s := v.Addr().Interface()
 131
 132         w := new(bytes.Buffer)
 133         if err := json.NewEncoder(w).Encode(s); err != nil {
 134                 panic(err)
 135         }
 136
 137         fmt.Printf("value: %+v\n", s)
 138         fmt.Printf("json:  %s", w.Bytes())
 139
 140         r := bytes.NewReader([]byte(`{"height":1.5,"age":10}`))
 141         if err := json.NewDecoder(r).Decode(s); err != nil {
 142                 panic(err)
 143         }
 144         fmt.Printf("value: %+v\n", s)
 145
 146         // Output:
 147         // value: &{Height:0.4 Age:2}
 148         // json:  {"height":0.4,"age":2}
 149         // value: &{Height:1.5 Age:10}
 150 }