mirror of
https://github.com/cedricve/go-onvif.git
synced 2026-04-23 00:07:12 +08:00
Rod Apeldoorn
03ded6c189
Updated discoverDevices and createUserToken functions to handle errors properly. This includes the rare possibility createUserToken could send a new SOAP fault message if a uuid can not be generated (only in out-of-memory situations). Added vendoring to prevent future dependency issues. Side Note: Had vendoring not been added, the uuid dependency would cause problems if this go-onvif package was added to a project using vendoring. This is due to go defaulting to a last commit to the master branch, while vendoring defaults to the last published version. This quirk was obvious after seeing the uuid package pushed the breaking change to the master without also pushing it as a new version.
129 lines
3.2 KiB
Go
129 lines
3.2 KiB
Go
// mxj - A collection of map[string]interface{} and associated XML and JSON utilities.
|
|
// Copyright 2012-2014 Charles Banning. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file
|
|
|
|
package mxj
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
)
|
|
|
|
const (
|
|
Cast = true // for clarity - e.g., mxj.NewMapXml(doc, mxj.Cast)
|
|
SafeEncoding = true // ditto - e.g., mv.Json(mxj.SafeEncoding)
|
|
)
|
|
|
|
type Map map[string]interface{}
|
|
|
|
// Allocate a Map.
|
|
func New() Map {
|
|
m := make(map[string]interface{}, 0)
|
|
return m
|
|
}
|
|
|
|
// Cast a Map to map[string]interface{}
|
|
func (mv Map) Old() map[string]interface{} {
|
|
return mv
|
|
}
|
|
|
|
// Return a copy of mv as a newly allocated Map. If the Map only contains string,
|
|
// numeric, map[string]interface{}, and []interface{} values, then it can be thought
|
|
// of as a "deep copy." Copying a structure (or structure reference) value is subject
|
|
// to the noted restrictions.
|
|
// NOTE: If 'mv' includes structure values with, possibly, JSON encoding tags
|
|
// then only public fields of the structure are in the new Map - and with
|
|
// keys that conform to any encoding tag instructions. The structure itself will
|
|
// be represented as a map[string]interface{} value.
|
|
func (mv Map) Copy() (Map, error) {
|
|
// this is the poor-man's deep copy
|
|
// not efficient, but it works
|
|
j, jerr := mv.Json()
|
|
// must handle, we don't know how mv got built
|
|
if jerr != nil {
|
|
return nil, jerr
|
|
}
|
|
return NewMapJson(j)
|
|
}
|
|
|
|
// --------------- StringIndent ... from x2j.WriteMap -------------
|
|
|
|
// Pretty print a Map.
|
|
func (mv Map) StringIndent(offset ...int) string {
|
|
return writeMap(map[string]interface{}(mv), true, true, offset...)
|
|
}
|
|
|
|
// Pretty print a Map without the value type information - just key:value entries.
|
|
func (mv Map) StringIndentNoTypeInfo(offset ...int) string {
|
|
return writeMap(map[string]interface{}(mv), false, true, offset...)
|
|
}
|
|
|
|
// writeMap - dumps the map[string]interface{} for examination.
|
|
// 'typeInfo' causes value type to be printed.
|
|
// 'offset' is initial indentation count; typically: Write(m).
|
|
func writeMap(m interface{}, typeInfo, root bool, offset ...int) string {
|
|
var indent int
|
|
if len(offset) == 1 {
|
|
indent = offset[0]
|
|
}
|
|
|
|
var s string
|
|
switch m.(type) {
|
|
case []interface{}:
|
|
if typeInfo {
|
|
s += "[[]interface{}]"
|
|
}
|
|
for _, v := range m.([]interface{}) {
|
|
s += "\n"
|
|
for i := 0; i < indent; i++ {
|
|
s += " "
|
|
}
|
|
s += writeMap(v, typeInfo, false, indent+1)
|
|
}
|
|
case map[string]interface{}:
|
|
list := make([][2]string, len(m.(map[string]interface{})))
|
|
var n int
|
|
for k, v := range m.(map[string]interface{}) {
|
|
list[n][0] = k
|
|
list[n][1] = writeMap(v, typeInfo, false, indent+1)
|
|
n++
|
|
}
|
|
sort.Sort(mapList(list))
|
|
for _, v := range list {
|
|
if root {
|
|
root = false
|
|
} else {
|
|
s += "\n"
|
|
}
|
|
for i := 0; i < indent; i++ {
|
|
s += " "
|
|
}
|
|
s += v[0] + " : " + v[1]
|
|
}
|
|
default:
|
|
if typeInfo {
|
|
s += fmt.Sprintf("[%T] %+v", m, m)
|
|
} else {
|
|
s += fmt.Sprintf("%+v", m)
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
// ======================== utility ===============
|
|
|
|
type mapList [][2]string
|
|
|
|
func (ml mapList) Len() int {
|
|
return len(ml)
|
|
}
|
|
|
|
func (ml mapList) Swap(i, j int) {
|
|
ml[i], ml[j] = ml[j], ml[i]
|
|
}
|
|
|
|
func (ml mapList) Less(i, j int) bool {
|
|
return ml[i][0] <= ml[j][0]
|
|
}
|