libgo/go/syscall/js/typedarray.go

   1 // Copyright 2018 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 // +build js,wasm
   6
   7 package js
   8
   9 import (
  10         "sync"
  11         "unsafe"
  12 )
  13
  14 var (
  15         int8Array    = Global().Get("Int8Array")
  16         int16Array   = Global().Get("Int16Array")
  17         int32Array   = Global().Get("Int32Array")
  18         uint8Array   = Global().Get("Uint8Array")
  19         uint16Array  = Global().Get("Uint16Array")
  20         uint32Array  = Global().Get("Uint32Array")
  21         float32Array = Global().Get("Float32Array")
  22         float64Array = Global().Get("Float64Array")
  23 )
  24
  25 // TypedArray represents a JavaScript typed array.
  26 type TypedArray struct {
  27         Value
  28 }
  29
  30 // Release frees up resources allocated for the typed array.
  31 // The typed array and its buffer must not be accessed after calling Release.
  32 func (a TypedArray) Release() {
  33         openTypedArraysMutex.Lock()
  34         delete(openTypedArrays, a)
  35         openTypedArraysMutex.Unlock()
  36 }
  37
  38 var (
  39         openTypedArraysMutex sync.Mutex
  40         openTypedArrays      = make(map[TypedArray]interface{})
  41 )
  42
  43 // TypedArrayOf returns a JavaScript typed array backed by the slice's underlying array.
  44 //
  45 // The supported types are []int8, []int16, []int32, []uint8, []uint16, []uint32, []float32 and []float64.
  46 // Passing an unsupported value causes a panic.
  47 //
  48 // TypedArray.Release must be called to free up resources when the typed array will not be used any more.
  49 func TypedArrayOf(slice interface{}) TypedArray {
  50         a := TypedArray{typedArrayOf(slice)}
  51         openTypedArraysMutex.Lock()
  52         openTypedArrays[a] = slice
  53         openTypedArraysMutex.Unlock()
  54         return a
  55 }
  56
  57 func typedArrayOf(slice interface{}) Value {
  58         switch slice := slice.(type) {
  59         case []int8:
  60                 if len(slice) == 0 {
  61                         return int8Array.New(memory.Get("buffer"), 0, 0)
  62                 }
  63                 return int8Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  64         case []int16:
  65                 if len(slice) == 0 {
  66                         return int16Array.New(memory.Get("buffer"), 0, 0)
  67                 }
  68                 return int16Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  69         case []int32:
  70                 if len(slice) == 0 {
  71                         return int32Array.New(memory.Get("buffer"), 0, 0)
  72                 }
  73                 return int32Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  74         case []uint8:
  75                 if len(slice) == 0 {
  76                         return uint8Array.New(memory.Get("buffer"), 0, 0)
  77                 }
  78                 return uint8Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  79         case []uint16:
  80                 if len(slice) == 0 {
  81                         return uint16Array.New(memory.Get("buffer"), 0, 0)
  82                 }
  83                 return uint16Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  84         case []uint32:
  85                 if len(slice) == 0 {
  86                         return uint32Array.New(memory.Get("buffer"), 0, 0)
  87                 }
  88                 return uint32Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  89         case []float32:
  90                 if len(slice) == 0 {
  91                         return float32Array.New(memory.Get("buffer"), 0, 0)
  92                 }
  93                 return float32Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  94         case []float64:
  95                 if len(slice) == 0 {
  96                         return float64Array.New(memory.Get("buffer"), 0, 0)
  97                 }
  98                 return float64Array.New(memory.Get("buffer"), unsafe.Pointer(&slice[0]), len(slice))
  99         default:
 100                 panic("TypedArrayOf: not a supported slice")
 101         }
 102 }