| // 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 { |
| } |
| |
| 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; |
| } |
| |
| 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; |
| */ |