dbus.go - external/github.com/godbus/dbus - Git at Google

 package dbus

 import (
 	"errors"
 	"reflect"
 	"strings"
 )

 var (
 	byteType        = reflect.TypeOf(byte(0))
 	boolType        = reflect.TypeOf(false)
 	uint8Type       = reflect.TypeOf(uint8(0))
 	int16Type       = reflect.TypeOf(int16(0))
 	uint16Type      = reflect.TypeOf(uint16(0))
 	int32Type       = reflect.TypeOf(int32(0))
 	uint32Type      = reflect.TypeOf(uint32(0))
 	int64Type       = reflect.TypeOf(int64(0))
 	uint64Type      = reflect.TypeOf(uint64(0))
 	float64Type     = reflect.TypeOf(float64(0))
 	stringType      = reflect.TypeOf("")
 	signatureType   = reflect.TypeOf(Signature{""})
 	objectPathType  = reflect.TypeOf(ObjectPath(""))
 	variantType     = reflect.TypeOf(Variant{Signature{""}, nil})
 	interfacesType  = reflect.TypeOf([]interface{}{})
 	unixFDType      = reflect.TypeOf(UnixFD(0))
 	unixFDIndexType = reflect.TypeOf(UnixFDIndex(0))
 )

 // An InvalidTypeError signals that a value which cannot be represented in the
 // D-Bus wire format was passed to a function.
 type InvalidTypeError struct {
 	Type reflect.Type
 }

 func (e InvalidTypeError) Error() string {
 	return "dbus: invalid type " + e.Type.String()
 }

 // Store copies the values contained in src to dest, which must be a slice of
 // pointers. It converts slices of interfaces from src to corresponding structs
 // in dest. An error is returned if the lengths of src and dest or the types of
 // their elements don't match.
 func Store(src []interface{}, dest ...interface{}) error {
 	if len(src) != len(dest) {
 		return errors.New("dbus.Store: length mismatch")
 	}

 	for i := range src {
 		if err := store(src[i], dest[i]); err != nil {
 			return err
 		}
 	}
 	return nil
 }

 func store(src, dest interface{}) error {
 	if reflect.TypeOf(dest).Elem() == reflect.TypeOf(src) {
 		reflect.ValueOf(dest).Elem().Set(reflect.ValueOf(src))
 		return nil
 	} else if hasStruct(dest) {
 		return storeStruct(src, dest)
 	} else if hasInterface(dest) {
 		return storeInterfaceContainer(src, dest)
 	} else {
 		return errors.New("dbus.Store: type mismatch")
 	}
 }

 func storeStruct(src, dest interface{}) error {
 	rv := reflect.ValueOf(dest)
 	if rv.Kind() == reflect.Interface || rv.Kind() == reflect.Ptr {
 		rv = rv.Elem()
 	}
 	switch rv.Kind() {
 	case reflect.Struct:
 		vs, ok := src.([]interface{})
 		if !ok {
 			return errors.New("dbus.Store: type mismatch")
 		}
 		t := rv.Type()
 		ndest := make([]interface{}, 0, rv.NumField())
 		for i := 0; i < rv.NumField(); i++ {
 			field := t.Field(i)
 			if field.PkgPath == "" && field.Tag.Get("dbus") != "-" {
 				ndest = append(ndest, rv.Field(i).Addr().Interface())

 			}
 		}
 		if len(vs) != len(ndest) {
 			return errors.New("dbus.Store: type mismatch")
 		}
 		err := Store(vs, ndest...)
 		if err != nil {
 			return errors.New("dbus.Store: type mismatch")
 		}
 	case reflect.Slice:
 		sv := reflect.ValueOf(src)
 		if sv.Kind() != reflect.Slice {
 			return errors.New("dbus.Store: type mismatch")
 		}
 		rv.Set(reflect.MakeSlice(rv.Type(), sv.Len(), sv.Len()))
 		for i := 0; i < sv.Len(); i++ {
 			if err := store(sv.Index(i).Interface(), rv.Index(i).Addr().Interface()); err != nil {
 				return err
 			}
 		}
 	case reflect.Map:
 		sv := reflect.ValueOf(src)
 		if sv.Kind() != reflect.Map {
 			return errors.New("dbus.Store: type mismatch")
 		}
 		keys := sv.MapKeys()
 		rv.Set(reflect.MakeMap(sv.Type()))
 		for _, key := range keys {
 			v := reflect.New(sv.Type().Elem())
 			if err := store(v, sv.MapIndex(key).Interface()); err != nil {
 				return err
 			}
 			rv.SetMapIndex(key, v.Elem())
 		}
 	default:
 		return errors.New("dbus.Store: type mismatch")
 	}
 	return nil
 }

 func storeInterfaceContainer(src, dest interface{}) error {
 	rv := reflect.ValueOf(dest).Elem()
 	switch rv.Kind() {
 	case reflect.Interface:
 		return storeInterfaceValue(src, dest)
 	case reflect.Slice:
 		sv := reflect.ValueOf(src)
 		if sv.Kind() != reflect.Slice {
 			return errors.New("dbus.Store: type mismatch")
 		}
 		rv.Set(reflect.MakeSlice(rv.Type(), sv.Len(), sv.Len()))
 		for i := 0; i < sv.Len(); i++ {
 			v := newInterfaceImplValue(sv.Index(i))
 			err := store(getVariantValue(sv.Index(i)),
 				v.Interface())
 			if err != nil {
 				return err
 			}
 			rv.Index(i).Set(v.Elem())
 		}
 	case reflect.Map:
 		sv := reflect.ValueOf(src)
 		if sv.Kind() != reflect.Map {
 			return errors.New("dbus.Store: type mismatch")
 		}
 		keys := sv.MapKeys()
 		rv.Set(reflect.MakeMap(rv.Type()))
 		for _, key := range keys {
 			elemv := sv.MapIndex(key)
 			v := newInterfaceImplValue(elemv)
 			err := store(getVariantValue(elemv),
 				v.Interface())
 			if err != nil {
 				return err
 			}
 			rv.SetMapIndex(key, v.Elem())
 		}
 	default:
 		return errors.New("dbus.Store: type mismatch")
 	}
 	return nil
 }

 func getVariantValue(in reflect.Value) interface{} {
 	if in.Type() == variantType {
 		return in.Interface().(Variant).Value()
 	}
 	return in.Interface()
 }

 func newInterfaceImplValue(val reflect.Value) reflect.Value {
 	ifaceType := reflect.TypeOf((*interface{})(nil)).Elem()
 	if !hasVariant(val.Type()) {
 		return reflect.New(val.Type())
 	}
 	switch val.Kind() {
 	case reflect.Map:
 		return reflect.New(reflect.MapOf(val.Type().Key(),
 			ifaceType))
 	case reflect.Slice:
 		return reflect.New(reflect.SliceOf(ifaceType))
 	default:
 		return newInterfaceImplValue(
 			reflect.ValueOf(
 				val.Interface().(Variant).Value()))
 	}
 }

 func storeInterfaceValue(src, dest interface{}) error {
 	sv := reflect.ValueOf(src)
 	if sv.Type() == variantType {
 		store(src.(Variant).Value(), dest)
 	} else {
 		reflect.ValueOf(dest).Elem().Set(
 			reflect.ValueOf(src))
 	}
 	return nil
 }

 func hasStruct(v interface{}) bool {
 	return hasKind(v, reflect.Struct)
 }

 func hasInterface(v interface{}) bool {
 	return hasKind(v, reflect.Interface)
 }

 func hasKind(v interface{}, kind reflect.Kind) bool {
 	t := reflect.TypeOf(v)
 	for {
 		switch t.Kind() {
 		case kind:
 			return true
 		case reflect.Slice, reflect.Ptr, reflect.Map:
 			t = t.Elem()
 		default:
 			return false
 		}
 	}
 }

 func hasVariant(t reflect.Type) bool {
 	for {
 		if t == variantType {
 			return true
 		}
 		switch t.Kind() {
 		case reflect.Slice, reflect.Ptr, reflect.Map:
 			t = t.Elem()
 		default:
 			return false
 		}
 	}
 }

 // An ObjectPath is an object path as defined by the D-Bus spec.
 type ObjectPath string

 // IsValid returns whether the object path is valid.
 func (o ObjectPath) IsValid() bool {
 	s := string(o)
 	if len(s) == 0 {
 		return false
 	}
 	if s[0] != '/' {
 		return false
 	}
 	if s[len(s)-1] == '/' && len(s) != 1 {
 		return false
 	}
 	// probably not used, but technically possible
 	if s == "/" {
 		return true
 	}
 	split := strings.Split(s[1:], "/")
 	for _, v := range split {
 		if len(v) == 0 {
 			return false
 		}
 		for _, c := range v {
 			if !isMemberChar(c) {
 				return false
 			}
 		}
 	}
 	return true
 }

 // A UnixFD is a Unix file descriptor sent over the wire. See the package-level
 // documentation for more information about Unix file descriptor passsing.
 type UnixFD int32

 // A UnixFDIndex is the representation of a Unix file descriptor in a message.
 type UnixFDIndex uint32

 // alignment returns the alignment of values of type t.
 func alignment(t reflect.Type) int {
 	switch t {
 	case variantType:
 		return 1
 	case objectPathType:
 		return 4
 	case signatureType:
 		return 1
 	case interfacesType:
 		return 4
 	}
 	switch t.Kind() {
 	case reflect.Uint8:
 		return 1
 	case reflect.Uint16, reflect.Int16:
 		return 2
 	case reflect.Uint32, reflect.Int32, reflect.String, reflect.Array, reflect.Slice, reflect.Map:
 		return 4
 	case reflect.Uint64, reflect.Int64, reflect.Float64, reflect.Struct:
 		return 8
 	case reflect.Ptr:
 		return alignment(t.Elem())
 	}
 	return 1
 }

 // isKeyType returns whether t is a valid type for a D-Bus dict.
 func isKeyType(t reflect.Type) bool {
 	switch t.Kind() {
 	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
 		reflect.Int16, reflect.Int32, reflect.Int64, reflect.Float64,
 		reflect.String:

 		return true
 	}
 	return false
 }

 // isValidInterface returns whether s is a valid name for an interface.
 func isValidInterface(s string) bool {
 	if len(s) == 0 || len(s) > 255 || s[0] == '.' {
 		return false
 	}
 	elem := strings.Split(s, ".")
 	if len(elem) < 2 {
 		return false
 	}
 	for _, v := range elem {
 		if len(v) == 0 {
 			return false
 		}
 		if v[0] >= '0' && v[0] <= '9' {
 			return false
 		}
 		for _, c := range v {
 			if !isMemberChar(c) {
 				return false
 			}
 		}
 	}
 	return true
 }

 // isValidMember returns whether s is a valid name for a member.
 func isValidMember(s string) bool {
 	if len(s) == 0 || len(s) > 255 {
 		return false
 	}
 	i := strings.Index(s, ".")
 	if i != -1 {
 		return false
 	}
 	if s[0] >= '0' && s[0] <= '9' {
 		return false
 	}
 	for _, c := range s {
 		if !isMemberChar(c) {
 			return false
 		}
 	}
 	return true
 }

 func isMemberChar(c rune) bool {
 	return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') ||
 		(c >= 'a' && c <= 'z') || c == '_'
 }
	package dbus

	import (
	"errors"
	"reflect"
	"strings"
	)

	var (
	byteType = reflect.TypeOf(byte(0))
	boolType = reflect.TypeOf(false)
	uint8Type = reflect.TypeOf(uint8(0))
	int16Type = reflect.TypeOf(int16(0))
	uint16Type = reflect.TypeOf(uint16(0))
	int32Type = reflect.TypeOf(int32(0))
	uint32Type = reflect.TypeOf(uint32(0))
	int64Type = reflect.TypeOf(int64(0))
	uint64Type = reflect.TypeOf(uint64(0))
	float64Type = reflect.TypeOf(float64(0))
	stringType = reflect.TypeOf("")
	signatureType = reflect.TypeOf(Signature{""})
	objectPathType = reflect.TypeOf(ObjectPath(""))
	variantType = reflect.TypeOf(Variant{Signature{""}, nil})
	interfacesType = reflect.TypeOf([]interface{}{})
	unixFDType = reflect.TypeOf(UnixFD(0))
	unixFDIndexType = reflect.TypeOf(UnixFDIndex(0))
	)

	// An InvalidTypeError signals that a value which cannot be represented in the
	// D-Bus wire format was passed to a function.
	type InvalidTypeError struct {
	Type reflect.Type
	}

	func (e InvalidTypeError) Error() string {
	return "dbus: invalid type " + e.Type.String()
	}

	// Store copies the values contained in src to dest, which must be a slice of
	// pointers. It converts slices of interfaces from src to corresponding structs
	// in dest. An error is returned if the lengths of src and dest or the types of
	// their elements don't match.
	func Store(src []interface{}, dest ...interface{}) error {
	if len(src) != len(dest) {
	return errors.New("dbus.Store: length mismatch")
	}

	for i := range src {
	if err := store(src[i], dest[i]); err != nil {
	return err
	}
	}
	return nil
	}

	func store(src, dest interface{}) error {
	if reflect.TypeOf(dest).Elem() == reflect.TypeOf(src) {
	reflect.ValueOf(dest).Elem().Set(reflect.ValueOf(src))
	return nil
	} else if hasStruct(dest) {
	return storeStruct(src, dest)
	} else if hasInterface(dest) {
	return storeInterfaceContainer(src, dest)
	} else {
	return errors.New("dbus.Store: type mismatch")
	}
	}

	func storeStruct(src, dest interface{}) error {
	rv := reflect.ValueOf(dest)
	if rv.Kind() == reflect.Interface \|\| rv.Kind() == reflect.Ptr {
	rv = rv.Elem()
	}
	switch rv.Kind() {
	case reflect.Struct:
	vs, ok := src.([]interface{})
	if !ok {
	return errors.New("dbus.Store: type mismatch")
	}
	t := rv.Type()
	ndest := make([]interface{}, 0, rv.NumField())
	for i := 0; i < rv.NumField(); i++ {
	field := t.Field(i)
	if field.PkgPath == "" && field.Tag.Get("dbus") != "-" {
	ndest = append(ndest, rv.Field(i).Addr().Interface())

	}
	}
	if len(vs) != len(ndest) {
	return errors.New("dbus.Store: type mismatch")
	}
	err := Store(vs, ndest...)
	if err != nil {
	return errors.New("dbus.Store: type mismatch")
	}
	case reflect.Slice:
	sv := reflect.ValueOf(src)
	if sv.Kind() != reflect.Slice {
	return errors.New("dbus.Store: type mismatch")
	}
	rv.Set(reflect.MakeSlice(rv.Type(), sv.Len(), sv.Len()))
	for i := 0; i < sv.Len(); i++ {
	if err := store(sv.Index(i).Interface(), rv.Index(i).Addr().Interface()); err != nil {
	return err
	}
	}
	case reflect.Map:
	sv := reflect.ValueOf(src)
	if sv.Kind() != reflect.Map {
	return errors.New("dbus.Store: type mismatch")
	}
	keys := sv.MapKeys()
	rv.Set(reflect.MakeMap(sv.Type()))
	for _, key := range keys {
	v := reflect.New(sv.Type().Elem())
	if err := store(v, sv.MapIndex(key).Interface()); err != nil {
	return err
	}
	rv.SetMapIndex(key, v.Elem())
	}
	default:
	return errors.New("dbus.Store: type mismatch")
	}
	return nil
	}

	func storeInterfaceContainer(src, dest interface{}) error {
	rv := reflect.ValueOf(dest).Elem()
	switch rv.Kind() {
	case reflect.Interface:
	return storeInterfaceValue(src, dest)
	case reflect.Slice:
	sv := reflect.ValueOf(src)
	if sv.Kind() != reflect.Slice {
	return errors.New("dbus.Store: type mismatch")
	}
	rv.Set(reflect.MakeSlice(rv.Type(), sv.Len(), sv.Len()))
	for i := 0; i < sv.Len(); i++ {
	v := newInterfaceImplValue(sv.Index(i))
	err := store(getVariantValue(sv.Index(i)),
	v.Interface())
	if err != nil {
	return err
	}
	rv.Index(i).Set(v.Elem())
	}
	case reflect.Map:
	sv := reflect.ValueOf(src)
	if sv.Kind() != reflect.Map {
	return errors.New("dbus.Store: type mismatch")
	}
	keys := sv.MapKeys()
	rv.Set(reflect.MakeMap(rv.Type()))
	for _, key := range keys {
	elemv := sv.MapIndex(key)
	v := newInterfaceImplValue(elemv)
	err := store(getVariantValue(elemv),
	v.Interface())
	if err != nil {
	return err
	}
	rv.SetMapIndex(key, v.Elem())
	}
	default:
	return errors.New("dbus.Store: type mismatch")
	}
	return nil
	}

	func getVariantValue(in reflect.Value) interface{} {
	if in.Type() == variantType {
	return in.Interface().(Variant).Value()
	}
	return in.Interface()
	}

	func newInterfaceImplValue(val reflect.Value) reflect.Value {
	ifaceType := reflect.TypeOf((*interface{})(nil)).Elem()
	if !hasVariant(val.Type()) {
	return reflect.New(val.Type())
	}
	switch val.Kind() {
	case reflect.Map:
	return reflect.New(reflect.MapOf(val.Type().Key(),
	ifaceType))
	case reflect.Slice:
	return reflect.New(reflect.SliceOf(ifaceType))
	default:
	return newInterfaceImplValue(
	reflect.ValueOf(
	val.Interface().(Variant).Value()))
	}
	}

	func storeInterfaceValue(src, dest interface{}) error {
	sv := reflect.ValueOf(src)
	if sv.Type() == variantType {
	store(src.(Variant).Value(), dest)
	} else {
	reflect.ValueOf(dest).Elem().Set(
	reflect.ValueOf(src))
	}
	return nil
	}

	func hasStruct(v interface{}) bool {
	return hasKind(v, reflect.Struct)
	}

	func hasInterface(v interface{}) bool {
	return hasKind(v, reflect.Interface)
	}

	func hasKind(v interface{}, kind reflect.Kind) bool {
	t := reflect.TypeOf(v)
	for {
	switch t.Kind() {
	case kind:
	return true
	case reflect.Slice, reflect.Ptr, reflect.Map:
	t = t.Elem()
	default:
	return false
	}
	}
	}

	func hasVariant(t reflect.Type) bool {
	for {
	if t == variantType {
	return true
	}
	switch t.Kind() {
	case reflect.Slice, reflect.Ptr, reflect.Map:
	t = t.Elem()
	default:
	return false
	}
	}
	}

	// An ObjectPath is an object path as defined by the D-Bus spec.
	type ObjectPath string

	// IsValid returns whether the object path is valid.
	func (o ObjectPath) IsValid() bool {
	s := string(o)
	if len(s) == 0 {
	return false
	}
	if s[0] != '/' {
	return false
	}
	if s[len(s)-1] == '/' && len(s) != 1 {
	return false
	}
	// probably not used, but technically possible
	if s == "/" {
	return true
	}
	split := strings.Split(s[1:], "/")
	for _, v := range split {
	if len(v) == 0 {
	return false
	}
	for _, c := range v {
	if !isMemberChar(c) {
	return false
	}
	}
	}
	return true
	}

	// A UnixFD is a Unix file descriptor sent over the wire. See the package-level
	// documentation for more information about Unix file descriptor passsing.
	type UnixFD int32

	// A UnixFDIndex is the representation of a Unix file descriptor in a message.
	type UnixFDIndex uint32

	// alignment returns the alignment of values of type t.
	func alignment(t reflect.Type) int {
	switch t {
	case variantType:
	return 1
	case objectPathType:
	return 4
	case signatureType:
	return 1
	case interfacesType:
	return 4
	}
	switch t.Kind() {
	case reflect.Uint8:
	return 1
	case reflect.Uint16, reflect.Int16:
	return 2
	case reflect.Uint32, reflect.Int32, reflect.String, reflect.Array, reflect.Slice, reflect.Map:
	return 4
	case reflect.Uint64, reflect.Int64, reflect.Float64, reflect.Struct:
	return 8
	case reflect.Ptr:
	return alignment(t.Elem())
	}
	return 1
	}

	// isKeyType returns whether t is a valid type for a D-Bus dict.
	func isKeyType(t reflect.Type) bool {
	switch t.Kind() {
	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
	reflect.Int16, reflect.Int32, reflect.Int64, reflect.Float64,
	reflect.String:

	return true
	}
	return false
	}

	// isValidInterface returns whether s is a valid name for an interface.
	func isValidInterface(s string) bool {
	if len(s) == 0 \|\| len(s) > 255 \|\| s[0] == '.' {
	return false
	}
	elem := strings.Split(s, ".")
	if len(elem) < 2 {
	return false
	}
	for _, v := range elem {
	if len(v) == 0 {
	return false
	}
	if v[0] >= '0' && v[0] <= '9' {
	return false
	}
	for _, c := range v {
	if !isMemberChar(c) {
	return false
	}
	}
	}
	return true
	}

	// isValidMember returns whether s is a valid name for a member.
	func isValidMember(s string) bool {
	if len(s) == 0 \|\| len(s) > 255 {
	return false
	}
	i := strings.Index(s, ".")
	if i != -1 {
	return false
	}
	if s[0] >= '0' && s[0] <= '9' {
	return false
	}
	for _, c := range s {
	if !isMemberChar(c) {
	return false
	}
	}
	return true
	}

	func isMemberChar(c rune) bool {
	return (c >= '0' && c <= '9') \|\| (c >= 'A' && c <= 'Z') \|\|
	(c >= 'a' && c <= 'z') \|\| c == '_'
	}