// NewSlice returns a slice with the given data.
979554
func NewSlice(data *C.char, size C.size_t) *Slice {
	return &Slice{data, size, false}
}
40491
func (v ByteView) ByteSlice() []byte {
	if v.b != nil {
		return cloneBytes(v.b)
	}
	return []byte(v.s)
}
452142
func UintSlice(src []uint) []*uint {
	dst := make([]*uint, len(src))
	for i := 0; i < len(src); i++ {
		dst[i] = &(src[i])
	}
	return dst
}
1020743
func (mmap MarshalMap) StringSlice(key string) ([]string, error) {
	return mmap.StringArray(key)
}
256480
func (c *Cmd) ExpectSlice(resp ...interface{}) *Cmd {
	response := []interface{}{}
	for _, r := range resp {
		response = append(response, r)
	}
	c.Responses = append(c.Responses, Response{response, nil})
	return c
}
824685
func (st StackTrace) formatSlice(s fmt.State, verb rune) {
	io.WriteString(s, "[")
	for i, f := range st {
		if i > 0 {
			io.WriteString(s, " ")
		}
		f.Format(s, verb)
	}
	io.WriteString(s, "]")
}
528483
func InKeywordSlice(a Keyword, list []Keyword) bool {
	for _, b := range list {
		if b == a {
			return true
		}
	}
	return false
}
1108017
func NewStringSliceResult(val []string, err error) *StringSliceCmd {
	var cmd StringSliceCmd
	cmd.val = val
	cmd.setErr(err)
	return &cmd
}
658185
func (e *Env) LoadSlice(s []string) {
	if len(s) == 0 {
		return
	}
	if e.env == nil {
		e.env = make(map[string]string, len(s))
	}
	for _, entry := range s {
		e.SetEntry(entry)
	}
}
267770
func (d PixSlice) Slice(newSliceType reflect.Type) interface{} {
	sv := reflect.ValueOf(d)
	newSlice := reflect.New(newSliceType)
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(newSlice.Pointer()))
	hdr.Cap = sv.Cap() * int(sv.Type().Elem().Size()) / int(newSliceType.Elem().Size())
	hdr.Len = sv.Len() * int(sv.Type().Elem().Size()) / int(newSliceType.Elem().Size())
	hdr.Data = uintptr(sv.Pointer())
	return newSlice.Elem().Interface()
}
996781
func NewSliceFloat64Stats() SliceFloat64Stats {
	stats := SliceFloat64Stats{
		Len:    0,
		Max:    0,
		Mean:   0,
		Median: 0,
		Min:    0,
		Sum:    0}
	return stats
}
41607
func (w *Writer) WriteSlice(slice []reflect.Value) {
	setWriterRef(w, nil, nil)
	count := len(slice)
	if count == 0 {
		writeEmptyList(w)
		return
	}
	writeListHeader(w, count)
	for i := range slice {
		w.WriteValue(slice[i])
	}
	writeListFooter(w)
}
634214
func (ns *Namespace) IsSlice(v interface{}) bool {
	return reflect.ValueOf(v).Kind() == reflect.Slice
}
846368
func slice(d Document) interface{} {
	documentType := reflect.TypeOf(d)
	documentSlice := reflect.MakeSlice(reflect.SliceOf(documentType), 0, 0)

	// Create a pointer to a slice value and set it to the slice
	return reflect.New(documentSlice.Type()).Interface()
}
259128
func NewStrip(openStr, closeStr string) *Strip {
	return &Strip{
		Open:  (len(openStr) > 2) && openStr[2] == '~',
		Close: (len(closeStr) > 2) && closeStr[len(closeStr)-3] == '~',
	}
}
614287
func (t *StringSliceFlag) StringSlice() []string {
	if t.viper == nil || t.value == nil {
		panic(ErrFlagNotYetBind1.New(nil, t.Name))
	}
	return *t.value
}
889787
func NewSQLStringSlice(s *[]string) *SQLStringSlice {
	if s == nil {
		return nil
	}
	data := SQLStringSlice(*s)
	return &data
}