| // Copyright 2009 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package vector | |
| //export Vector, New; | |
| /* | |
| import vector "vector" | |
| v := vector.New(); | |
| v.Insert(0, new(Foo)); | |
| v.Append(new(Foo)); | |
| v.Delete(0); | |
| for i := 0; i < v.Len(); i++ { f(v.At(i)); } | |
| */ | |
| type Element interface { | |
| } | |
| export type Vector struct { | |
| nalloc int; | |
| nelem int; | |
| elem *[]Element; | |
| } | |
| // BUG: workaround for non-constant allocation. | |
| // i must be a power of 10. | |
| func Alloc(i int) *[]Element { | |
| switch i { | |
| case 1: | |
| return new([1]Element); | |
| case 10: | |
| return new([10]Element); | |
| case 100: | |
| return new([100]Element); | |
| case 1000: | |
| return new([1000]Element); | |
| } | |
| print "bad size ", i, "\n"; | |
| panic "not known size\n"; | |
| } | |
| func is_pow10(i int) bool { | |
| switch i { | |
| case 1, 10, 100, 1000: | |
| return true; | |
| } | |
| return false; | |
| } | |
| export func New() *Vector { | |
| v := new(Vector); | |
| v.nelem = 0; | |
| v.nalloc = 1; | |
| v.elem = Alloc(v.nalloc); | |
| return v; | |
| } | |
| func (v *Vector) Len() int { | |
| return v.nelem; | |
| } | |
| func (v *Vector) At(i int) Element { | |
| if i < 0 || i >= v.nelem { | |
| panic "Vector.At(", i, ") out of range (size ", v.nelem, ")\n"; | |
| return nil; | |
| } | |
| return v.elem[i]; | |
| } | |
| func (v *Vector) Delete(i int) { | |
| if i < 0 || i >= v.nelem { | |
| panic "Delete out of range\n"; | |
| } | |
| for j := i+1; j < v.nelem; j++ { | |
| v.elem[j-1] = v.elem[j]; | |
| } | |
| v.nelem--; | |
| v.elem[v.nelem] = nil; | |
| } | |
| func (v *Vector) Insert(i int, e Element) { | |
| if i > v.nelem { | |
| panic "Del too large\n"; | |
| } | |
| if v.nelem == v.nalloc && is_pow10(v.nalloc) { | |
| n := Alloc(v.nalloc * 10); | |
| for j := 0; j < v.nalloc; j++ { | |
| n[j] = v.elem[j]; | |
| } | |
| v.elem = n; | |
| v.nalloc *= 10; | |
| } | |
| // make a hole | |
| for j := v.nelem; j > i; j-- { | |
| v.elem[j] = v.elem[j-1]; | |
| } | |
| v.elem[i] = e; | |
| v.nelem++; | |
| } | |
| func (v *Vector) Append(e Element) { | |
| v.Insert(v.nelem, e); | |
| } | |
| /* | |
| type I struct { val int; }; // BUG: can't be local; | |
| func Test() { | |
| i0 := new(I); i0.val = 0; | |
| i1 := new(I); i1.val = 11; | |
| i2 := new(I); i2.val = 222; | |
| i3 := new(I); i3.val = 3333; | |
| i4 := new(I); i4.val = 44444; | |
| v := New(); | |
| print "hi\n"; | |
| v.Insert(0, i4); | |
| v.Insert(0, i3); | |
| v.Insert(0, i2); | |
| v.Insert(0, i1); | |
| v.Insert(0, i0); | |
| for i := 0; i < v.Len(); i++ { | |
| print i, " ", v.At(i).(*I).val, "\n"; | |
| } | |
| } | |
| export Test; | |
| */ |