blob: 3c89ba7152ecd7ac0af46b5d749d43e032207267 [file] [log] [blame] [edit]
// Copyright 2021 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package list provides utilities for handling lists of dynamically-typed elements
package list
import (
"fmt"
"reflect"
)
// List is an interface to a list of dynamically-typed elements
type List interface {
// Count returns the number if items in the list
Count() int
// Get returns the element at the index i
Get(i int) interface{}
// Set assigns the element at the index i with v
Set(i int, v interface{})
// Append adds a single item, list, or slice of items to this List
Append(v interface{})
// Copy copies the elements at [dst..dst+count) to [src..src+count)
Copy(dst, src, count int)
// CopyFrom copies the elements [src..src+count) from the list l to the
// elements [dst..dst+count) in this list
CopyFrom(l List, dst, src, count int)
// Reduces the size of the list to count elements
Resize(count int)
// ElementType returns the type of the elements of the list
ElementType() reflect.Type
}
// Wrap returns a List that wraps a slice pointer
func Wrap(s interface{}) List {
ptr := reflect.ValueOf(s)
if ptr.Kind() != reflect.Ptr || ptr.Elem().Kind() != reflect.Slice {
panic(fmt.Errorf("Wrap() must be called with a pointer to slice. Got: %T", s))
}
return list{ptr.Elem()}
}
// New returns a new list of element type elem for n items
func New(elem reflect.Type, count int) List {
slice := reflect.SliceOf(elem)
return list{reflect.MakeSlice(slice, count, count)}
}
// Copy makes a shallow copy of the list
func Copy(l List) List {
out := New(l.ElementType(), l.Count())
out.CopyFrom(l, 0, 0, l.Count())
return out
}
type list struct{ v reflect.Value }
func (l list) Count() int {
return l.v.Len()
}
func (l list) Get(i int) interface{} {
return l.v.Index(i).Interface()
}
func (l list) Set(i int, v interface{}) {
l.v.Index(i).Set(reflect.ValueOf(v))
}
func (l list) Append(v interface{}) {
switch v := v.(type) {
case list:
l.v.Set(reflect.AppendSlice(l.v, reflect.Value(v.v)))
case List:
// v implements `List`, but isn't a `list`. Need to do a piece-wise copy
items := make([]reflect.Value, v.Count())
for i := range items {
items[i] = reflect.ValueOf(v.Get(i))
}
l.v.Set(reflect.Append(l.v, items...))
default:
r := reflect.ValueOf(v)
if r.Type() == l.v.Type() {
l.v.Set(reflect.AppendSlice(l.v, r))
return
}
l.v.Set(reflect.Append(l.v, reflect.ValueOf(v)))
}
}
func (l list) Copy(dst, src, count int) {
reflect.Copy(
l.v.Slice(dst, dst+count),
l.v.Slice(src, src+count),
)
}
func (l list) CopyFrom(o List, dst, src, count int) {
if o, ok := o.(list); ok {
reflect.Copy(
l.v.Slice(dst, dst+count),
o.v.Slice(src, src+count),
)
}
// v implements `List`, but isn't a `list`. Need to do a piece-wise copy
items := make([]reflect.Value, count)
for i := range items {
l.Set(dst+i, o.Get(src+i))
}
}
func (l list) Resize(count int) {
new := reflect.MakeSlice(l.v.Type(), count, count)
reflect.Copy(new, l.v)
l.v.Set(new)
}
func (l list) ElementType() reflect.Type {
return l.v.Type().Elem()
}