github.com/matm/etcd@v0.3.1-0.20140328024009-5b4a473f1453/third_party/code.google.com/p/goprotobuf/proto/pointer_unsafe.go (about) 1 // Go support for Protocol Buffers - Google's data interchange format 2 // 3 // Copyright 2012 The Go Authors. All rights reserved. 4 // http://code.google.com/p/goprotobuf/ 5 // 6 // Redistribution and use in source and binary forms, with or without 7 // modification, are permitted provided that the following conditions are 8 // met: 9 // 10 // * Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // * Redistributions in binary form must reproduce the above 13 // copyright notice, this list of conditions and the following disclaimer 14 // in the documentation and/or other materials provided with the 15 // distribution. 16 // * Neither the name of Google Inc. nor the names of its 17 // contributors may be used to endorse or promote products derived from 18 // this software without specific prior written permission. 19 // 20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 32 // +build !appengine 33 34 // This file contains the implementation of the proto field accesses using package unsafe. 35 36 package proto 37 38 import ( 39 "reflect" 40 "unsafe" 41 ) 42 43 // NOTE: These type_Foo functions would more idiomatically be methods, 44 // but Go does not allow methods on pointer types, and we must preserve 45 // some pointer type for the garbage collector. We use these 46 // funcs with clunky names as our poor approximation to methods. 47 // 48 // An alternative would be 49 // type structPointer struct { p unsafe.Pointer } 50 // but that does not registerize as well. 51 52 // A structPointer is a pointer to a struct. 53 type structPointer unsafe.Pointer 54 55 // toStructPointer returns a structPointer equivalent to the given reflect value. 56 func toStructPointer(v reflect.Value) structPointer { 57 return structPointer(unsafe.Pointer(v.Pointer())) 58 } 59 60 // IsNil reports whether p is nil. 61 func structPointer_IsNil(p structPointer) bool { 62 return p == nil 63 } 64 65 // Interface returns the struct pointer, assumed to have element type t, 66 // as an interface value. 67 func structPointer_Interface(p structPointer, t reflect.Type) interface{} { 68 return reflect.NewAt(t, unsafe.Pointer(p)).Interface() 69 } 70 71 // A field identifies a field in a struct, accessible from a structPointer. 72 // In this implementation, a field is identified by its byte offset from the start of the struct. 73 type field uintptr 74 75 // toField returns a field equivalent to the given reflect field. 76 func toField(f *reflect.StructField) field { 77 return field(f.Offset) 78 } 79 80 // invalidField is an invalid field identifier. 81 const invalidField = ^field(0) 82 83 // IsValid reports whether the field identifier is valid. 84 func (f field) IsValid() bool { 85 return f != ^field(0) 86 } 87 88 // Bytes returns the address of a []byte field in the struct. 89 func structPointer_Bytes(p structPointer, f field) *[]byte { 90 return (*[]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) 91 } 92 93 // BytesSlice returns the address of a [][]byte field in the struct. 94 func structPointer_BytesSlice(p structPointer, f field) *[][]byte { 95 return (*[][]byte)(unsafe.Pointer(uintptr(p) + uintptr(f))) 96 } 97 98 // Bool returns the address of a *bool field in the struct. 99 func structPointer_Bool(p structPointer, f field) **bool { 100 return (**bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) 101 } 102 103 // BoolSlice returns the address of a []bool field in the struct. 104 func structPointer_BoolSlice(p structPointer, f field) *[]bool { 105 return (*[]bool)(unsafe.Pointer(uintptr(p) + uintptr(f))) 106 } 107 108 // String returns the address of a *string field in the struct. 109 func structPointer_String(p structPointer, f field) **string { 110 return (**string)(unsafe.Pointer(uintptr(p) + uintptr(f))) 111 } 112 113 // StringSlice returns the address of a []string field in the struct. 114 func structPointer_StringSlice(p structPointer, f field) *[]string { 115 return (*[]string)(unsafe.Pointer(uintptr(p) + uintptr(f))) 116 } 117 118 // ExtMap returns the address of an extension map field in the struct. 119 func structPointer_ExtMap(p structPointer, f field) *map[int32]Extension { 120 return (*map[int32]Extension)(unsafe.Pointer(uintptr(p) + uintptr(f))) 121 } 122 123 // SetStructPointer writes a *struct field in the struct. 124 func structPointer_SetStructPointer(p structPointer, f field, q structPointer) { 125 *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) = q 126 } 127 128 // GetStructPointer reads a *struct field in the struct. 129 func structPointer_GetStructPointer(p structPointer, f field) structPointer { 130 return *(*structPointer)(unsafe.Pointer(uintptr(p) + uintptr(f))) 131 } 132 133 // StructPointerSlice the address of a []*struct field in the struct. 134 func structPointer_StructPointerSlice(p structPointer, f field) *structPointerSlice { 135 return (*structPointerSlice)(unsafe.Pointer(uintptr(p) + uintptr(f))) 136 } 137 138 // A structPointerSlice represents a slice of pointers to structs (themselves submessages or groups). 139 type structPointerSlice []structPointer 140 141 func (v *structPointerSlice) Len() int { return len(*v) } 142 func (v *structPointerSlice) Index(i int) structPointer { return (*v)[i] } 143 func (v *structPointerSlice) Append(p structPointer) { *v = append(*v, p) } 144 145 // A word32 is the address of a "pointer to 32-bit value" field. 146 type word32 **uint32 147 148 // IsNil reports whether *v is nil. 149 func word32_IsNil(p word32) bool { 150 return *p == nil 151 } 152 153 // Set sets *v to point at a newly allocated word set to x. 154 func word32_Set(p word32, o *Buffer, x uint32) { 155 if len(o.uint32s) == 0 { 156 o.uint32s = make([]uint32, uint32PoolSize) 157 } 158 o.uint32s[0] = x 159 *p = &o.uint32s[0] 160 o.uint32s = o.uint32s[1:] 161 } 162 163 // Get gets the value pointed at by *v. 164 func word32_Get(p word32) uint32 { 165 return **p 166 } 167 168 // Word32 returns the address of a *int32, *uint32, *float32, or *enum field in the struct. 169 func structPointer_Word32(p structPointer, f field) word32 { 170 return word32((**uint32)(unsafe.Pointer(uintptr(p) + uintptr(f)))) 171 } 172 173 // A word32Slice is a slice of 32-bit values. 174 type word32Slice []uint32 175 176 func (v *word32Slice) Append(x uint32) { *v = append(*v, x) } 177 func (v *word32Slice) Len() int { return len(*v) } 178 func (v *word32Slice) Index(i int) uint32 { return (*v)[i] } 179 180 // Word32Slice returns the address of a []int32, []uint32, []float32, or []enum field in the struct. 181 func structPointer_Word32Slice(p structPointer, f field) *word32Slice { 182 return (*word32Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) 183 } 184 185 // word64 is like word32 but for 64-bit values. 186 type word64 **uint64 187 188 func word64_Set(p word64, o *Buffer, x uint64) { 189 if len(o.uint64s) == 0 { 190 o.uint64s = make([]uint64, uint64PoolSize) 191 } 192 o.uint64s[0] = x 193 *p = &o.uint64s[0] 194 o.uint64s = o.uint64s[1:] 195 } 196 197 func word64_IsNil(p word64) bool { 198 return *p == nil 199 } 200 201 func word64_Get(p word64) uint64 { 202 return **p 203 } 204 205 func structPointer_Word64(p structPointer, f field) word64 { 206 return word64((**uint64)(unsafe.Pointer(uintptr(p) + uintptr(f)))) 207 } 208 209 // word64Slice is like word32Slice but for 64-bit values. 210 type word64Slice []uint64 211 212 func (v *word64Slice) Append(x uint64) { *v = append(*v, x) } 213 func (v *word64Slice) Len() int { return len(*v) } 214 func (v *word64Slice) Index(i int) uint64 { return (*v)[i] } 215 216 func structPointer_Word64Slice(p structPointer, f field) *word64Slice { 217 return (*word64Slice)(unsafe.Pointer(uintptr(p) + uintptr(f))) 218 }