versions/v1_4_0/mynewt-newt/newt/ycfg/ycfg.go - mynewt-documentation - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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 ycfg

 import (
 	"fmt"
 	"strings"

 	log "github.com/Sirupsen/logrus"
 	"github.com/spf13/cast"

 	"mynewt.apache.org/newt/newt/parse"
 )

 // YAML configuration object.  This is a substitute for a viper configuration
 // object, with the following newt-specific advantages:
 // 1. Case sensitive.
 // 2. Efficient conditionals based on syscfg values.
 //
 // A single YCfg setting is implemented as a tree of nodes.  Each word in the
 // setting name represents a node; each "." in the name is a link in the tree.
 // For example, the following syscfg lines:
 //
 // OS_MAIN_STACK_SIZE: 100
 // OS_MAIN_STACK_SIZE.BLE_DEVICE: 200
 // OS_MAIN_STACK_SIZE.SHELL_TASK: 300
 //
 // Is represented as the following tree:
 //
 //                      [OS_MAIN_STACK_SIZE (100)]
 //                     /                          \
 //            [BLE_DEVICE (200)]           [SHELL_TASK (300)]
 //
 // This allows us to quickly determine the value of OS_MAIN_STACK_SIZE.  After
 // finding the OS_MAIN_STACK_SIZE node, the logic is something like this:
 //
 // Is BLE_DEVICE true? --> 200
 // Is SHELL_TASK true? --> 300
 // Else: --> 100
 //
 // The tree structure also allows for arbitrary expressions as conditionals, as
 // opposed to simple setting names.  For example:
 //
 // OS_MAIN_STACK_SIZE: 100
 // OS_MAIN_STACK_SIZE.'(BLE_DEVICE && !SHELL_TASK): 200
 // OS_MAIN_STACK_SIZE.'(SHELL_TASK && !BLE_DEVICE): 300
 // OS_MAIN_STACK_SIZE.'(SHELL_TASK && BLE_DEVICE):  400
 //
 // Since each expression is a child node of the setting in question, they are
 // all known at the time of the lookup.  To determine the value of the setting,
 // each expression is parsed, and only the one evaluating to true is selected.
 type YCfg map[string]*YCfgNode

 type YCfgEntry struct {
 	Value interface{}
 	Expr  string
 }

 type YCfgNode struct {
 	Overwrite bool
 	Name      string
 	Value     interface{}
 	Children  YCfg
 	Parent    *YCfgNode
 }

 func (node *YCfgNode) addChild(name string) (*YCfgNode, error) {
 	if node.Children == nil {
 		node.Children = YCfg{}
 	}

 	if node.Children[name] != nil {
 		return nil, fmt.Errorf("Duplicate YCfgNode: %s", name)
 	}

 	child := &YCfgNode{
 		Name:   name,
 		Parent: node,
 	}
 	node.Children[name] = child

 	return child, nil
 }

 func (yc YCfg) Replace(key string, val interface{}) error {
 	elems := strings.Split(key, ".")
 	if len(elems) == 0 {
 		return fmt.Errorf("Invalid ycfg key: \"\"")
 	}

 	var overwrite bool
 	if elems[len(elems)-1] == "OVERWRITE" {
 		overwrite = true
 		elems = elems[:len(elems)-1]
 	}

 	var parent *YCfgNode
 	for i, e := range elems {
 		var parentChildren YCfg
 		if parent == nil {
 			parentChildren = yc
 		} else {
 			if parent.Children == nil {
 				parent.Children = YCfg{}
 			}
 			parentChildren = parent.Children
 		}
 		child := parentChildren[e]
 		if child == nil {
 			var err error
 			if parent != nil {
 				child, err = parent.addChild(e)
 				if err != nil {
 					return err
 				}
 			} else {
 				child = &YCfgNode{Name: e}
 				parentChildren[e] = child
 			}
 		}

 		if i == len(elems)-1 {
 			child.Overwrite = overwrite
 			child.Value = val
 		}

 		parent = child
 	}

 	return nil
 }

 func NewYCfg(kv map[string]interface{}) (YCfg, error) {
 	yc := YCfg{}

 	for k, v := range kv {
 		if err := yc.Replace(k, v); err != nil {
 			return nil, err
 		}
 	}

 	return yc, nil
 }

 func (yc YCfg) find(key string) *YCfgNode {
 	elems := strings.Split(key, ".")
 	if len(elems) == 0 {
 		return nil
 	}

 	cur := &YCfgNode{
 		Children: yc,
 	}
 	for _, e := range elems {
 		if cur.Children == nil {
 			return nil
 		}

 		cur = cur.Children[e]
 		if cur == nil {
 			return nil
 		}
 	}

 	return cur
 }

 func (yc YCfg) Get(key string, settings map[string]string) []YCfgEntry {
 	node := yc.find(key)
 	if node == nil {
 		return nil
 	}

 	entries := []YCfgEntry{}

 	if node.Value != nil {
 		entry := YCfgEntry{Value: node.Value}
 		entries = append(entries, entry)
 	}

 	for _, child := range node.Children {
 		val, err := parse.ParseAndEval(child.Name, settings)
 		if err != nil {
 			log.Error(err.Error())
 		} else if val {
 			entry := YCfgEntry{
 				Value: child.Value,
 				Expr:  child.Name,
 			}
 			if child.Overwrite {
 				return []YCfgEntry{entry}
 			}

 			entries = append(entries, entry)
 		}
 	}

 	return entries
 }

 func (yc YCfg) GetSlice(key string, settings map[string]string) []YCfgEntry {
 	sliceEntries := yc.Get(key, settings)
 	if len(sliceEntries) == 0 {
 		return nil
 	}

 	result := []YCfgEntry{}
 	for _, sliceEntry := range sliceEntries {
 		if sliceEntry.Value != nil {
 			slice, err := cast.ToSliceE(sliceEntry.Value)
 			if err != nil {
 				// Not a slice.  Put the single value in a new slice.
 				slice = []interface{}{sliceEntry.Value}
 			}
 			for _, v := range slice {
 				entry := YCfgEntry{
 					Value: v,
 					Expr:  sliceEntry.Expr,
 				}
 				result = append(result, entry)
 			}
 		}
 	}

 	return result
 }

 func (yc YCfg) GetValSlice(
 	key string, settings map[string]string) []interface{} {

 	entries := yc.GetSlice(key, settings)
 	if len(entries) == 0 {
 		return nil
 	}

 	vals := make([]interface{}, len(entries))
 	for i, e := range entries {
 		vals[i] = e.Value
 	}

 	return vals
 }

 func (yc YCfg) GetStringSlice(key string,
 	settings map[string]string) []YCfgEntry {

 	sliceEntries := yc.Get(key, settings)
 	if len(sliceEntries) == 0 {
 		return nil
 	}

 	result := []YCfgEntry{}
 	for _, sliceEntry := range sliceEntries {
 		if sliceEntry.Value != nil {
 			slice, err := cast.ToStringSliceE(sliceEntry.Value)
 			if err != nil {
 				// Not a slice.  Put the single value in a new slice.
 				slice = []string{cast.ToString(sliceEntry.Value)}
 			}
 			for _, v := range slice {
 				entry := YCfgEntry{
 					Value: v,
 					Expr:  sliceEntry.Expr,
 				}
 				result = append(result, entry)
 			}
 		}
 	}

 	return result
 }

 func (yc YCfg) GetValStringSlice(
 	key string, settings map[string]string) []string {

 	entries := yc.GetStringSlice(key, settings)
 	if len(entries) == 0 {
 		return nil
 	}

 	vals := make([]string, len(entries))
 	for i, e := range entries {
 		if e.Value != nil {
 			vals[i] = cast.ToString(e.Value)
 		}
 	}

 	return vals
 }

 func (yc YCfg) GetValStringSliceNonempty(
 	key string, settings map[string]string) []string {

 	strs := yc.GetValStringSlice(key, settings)
 	filtered := make([]string, 0, len(strs))
 	for _, s := range strs {
 		if s != "" {
 			filtered = append(filtered, s)
 		}
 	}

 	return filtered
 }

 func (yc YCfg) GetStringMap(
 	key string, settings map[string]string) map[string]YCfgEntry {

 	mapEntries := yc.Get(key, settings)
 	if len(mapEntries) == 0 {
 		return nil
 	}

 	result := map[string]YCfgEntry{}

 	for _, mapEntry := range mapEntries {
 		for k, v := range cast.ToStringMap(mapEntry.Value) {
 			entry := YCfgEntry{
 				Value: v,
 				Expr:  mapEntry.Expr,
 			}

 			// XXX: Report collisions?
 			result[k] = entry
 		}
 	}

 	return result
 }

 func (yc YCfg) GetValStringMap(
 	key string, settings map[string]string) map[string]interface{} {

 	entryMap := yc.GetStringMap(key, settings)

 	smap := make(map[string]interface{}, len(entryMap))
 	for k, v := range entryMap {
 		if v.Value != nil {
 			smap[k] = v.Value
 		}
 	}

 	return smap
 }

 func (yc YCfg) GetFirst(key string, settings map[string]string) (YCfgEntry, bool) {
 	entries := yc.Get(key, settings)
 	if len(entries) == 0 {
 		return YCfgEntry{}, false
 	}

 	return entries[0], true
 }

 func (yc YCfg) GetFirstVal(key string, settings map[string]string) interface{} {
 	entry, ok := yc.GetFirst(key, settings)
 	if !ok {
 		return nil
 	}

 	return entry.Value
 }

 func (yc YCfg) GetValString(key string, settings map[string]string) string {
 	entry, ok := yc.GetFirst(key, settings)
 	if !ok {
 		return ""
 	} else {
 		return cast.ToString(entry.Value)
 	}
 }

 func (yc YCfg) GetValInt(key string, settings map[string]string) int {
 	entry, ok := yc.GetFirst(key, settings)
 	if !ok {
 		return 0
 	} else {
 		return cast.ToInt(entry.Value)
 	}
 }

 func (yc YCfg) GetValBoolDflt(key string, settings map[string]string,
 	dflt bool) bool {

 	entry, ok := yc.GetFirst(key, settings)
 	if !ok {
 		return dflt
 	} else {
 		return cast.ToBool(entry.Value)
 	}
 }

 func (yc YCfg) GetValBool(key string, settings map[string]string) bool {
 	return yc.GetValBoolDflt(key, settings, false)
 }

 func (yc YCfg) GetStringMapString(key string,
 	settings map[string]string) map[string]YCfgEntry {

 	mapEntries := yc.Get(key, settings)
 	if len(mapEntries) == 0 {
 		return nil
 	}

 	result := map[string]YCfgEntry{}

 	for _, mapEntry := range mapEntries {
 		for k, v := range cast.ToStringMapString(mapEntry.Value) {
 			entry := YCfgEntry{
 				Value: v,
 				Expr:  mapEntry.Expr,
 			}

 			// XXX: Report collisions?
 			result[k] = entry
 		}
 	}

 	return result
 }

 func (yc YCfg) GetValStringMapString(key string,
 	settings map[string]string) map[string]string {

 	entryMap := yc.GetStringMapString(key, settings)

 	valMap := make(map[string]string, len(entryMap))
 	for k, v := range entryMap {
 		if v.Value != nil {
 			valMap[k] = cast.ToString(v.Value)
 		}
 	}

 	return valMap
 }

 func (node *YCfgNode) FullName() string {
 	tokens := []string{}

 	for n := node; n != nil; n = n.Parent {
 		tokens = append(tokens, n.Name)
 	}

 	last := len(tokens) - 1
 	for i := 0; i < len(tokens)/2; i++ {
 		tokens[i], tokens[last-i] = tokens[last-i], tokens[i]
 	}

 	return strings.Join(tokens, ".")
 }

 func (yc YCfg) Delete(name string) {
 	delete(yc, name)
 }

 func (yc YCfg) Traverse(cb func(node *YCfgNode, depth int)) {
 	var traverseLevel func(
 		node *YCfgNode,
 		cb func(node *YCfgNode, depth int),
 		depth int)

 	traverseLevel = func(
 		node *YCfgNode,
 		cb func(node *YCfgNode, depth int),
 		depth int) {

 		cb(node, depth)
 		for _, child := range node.Children {
 			traverseLevel(child, cb, depth+1)
 		}
 	}

 	for _, n := range yc {
 		traverseLevel(n, cb, 0)
 	}
 }

 func (yc YCfg) AllSettings() map[string]interface{} {
 	settings := map[string]interface{}{}

 	yc.Traverse(func(node *YCfgNode, depth int) {
 		if node.Value != nil {
 			settings[node.FullName()] = node.Value
 		}
 	})

 	return settings
 }

 func (yc YCfg) AllSettingsAsStrings() map[string]string {
 	settings := yc.AllSettings()
 	smap := make(map[string]string, len(settings))
 	for k, v := range settings {
 		smap[k] = fmt.Sprintf("%v", v)
 	}

 	return smap
 }

 func (yc YCfg) String() string {
 	lines := make([]string, 0, len(yc))
 	yc.Traverse(func(node *YCfgNode, depth int) {
 		line := strings.Repeat(" ", depth*4) + node.Name
 		if node.Value != nil {
 			line += fmt.Sprintf(": %+v", node.Value)
 		}
 		lines = append(lines, line)
 	})

 	return strings.Join(lines, "\n")
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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 ycfg

	import (
	"fmt"
	"strings"

	log "github.com/Sirupsen/logrus"
	"github.com/spf13/cast"

	"mynewt.apache.org/newt/newt/parse"
	)

	// YAML configuration object. This is a substitute for a viper configuration
	// object, with the following newt-specific advantages:
	// 1. Case sensitive.
	// 2. Efficient conditionals based on syscfg values.
	//
	// A single YCfg setting is implemented as a tree of nodes. Each word in the
	// setting name represents a node; each "." in the name is a link in the tree.
	// For example, the following syscfg lines:
	//
	// OS_MAIN_STACK_SIZE: 100
	// OS_MAIN_STACK_SIZE.BLE_DEVICE: 200
	// OS_MAIN_STACK_SIZE.SHELL_TASK: 300
	//
	// Is represented as the following tree:
	//
	// [OS_MAIN_STACK_SIZE (100)]
	// / \
	// [BLE_DEVICE (200)] [SHELL_TASK (300)]
	//
	// This allows us to quickly determine the value of OS_MAIN_STACK_SIZE. After
	// finding the OS_MAIN_STACK_SIZE node, the logic is something like this:
	//
	// Is BLE_DEVICE true? --> 200
	// Is SHELL_TASK true? --> 300
	// Else: --> 100
	//
	// The tree structure also allows for arbitrary expressions as conditionals, as
	// opposed to simple setting names. For example:
	//
	// OS_MAIN_STACK_SIZE: 100
	// OS_MAIN_STACK_SIZE.'(BLE_DEVICE && !SHELL_TASK): 200
	// OS_MAIN_STACK_SIZE.'(SHELL_TASK && !BLE_DEVICE): 300
	// OS_MAIN_STACK_SIZE.'(SHELL_TASK && BLE_DEVICE): 400
	//
	// Since each expression is a child node of the setting in question, they are
	// all known at the time of the lookup. To determine the value of the setting,
	// each expression is parsed, and only the one evaluating to true is selected.
	type YCfg map[string]*YCfgNode

	type YCfgEntry struct {
	Value interface{}
	Expr string
	}

	type YCfgNode struct {
	Overwrite bool
	Name string
	Value interface{}
	Children YCfg
	Parent *YCfgNode
	}

	func (node YCfgNode) addChild(name string) (YCfgNode, error) {
	if node.Children == nil {
	node.Children = YCfg{}
	}

	if node.Children[name] != nil {
	return nil, fmt.Errorf("Duplicate YCfgNode: %s", name)
	}

	child := &YCfgNode{
	Name: name,
	Parent: node,
	}
	node.Children[name] = child

	return child, nil
	}

	func (yc YCfg) Replace(key string, val interface{}) error {
	elems := strings.Split(key, ".")
	if len(elems) == 0 {
	return fmt.Errorf("Invalid ycfg key: \"\"")
	}

	var overwrite bool
	if elems[len(elems)-1] == "OVERWRITE" {
	overwrite = true
	elems = elems[:len(elems)-1]
	}

	var parent *YCfgNode
	for i, e := range elems {
	var parentChildren YCfg
	if parent == nil {
	parentChildren = yc
	} else {
	if parent.Children == nil {
	parent.Children = YCfg{}
	}
	parentChildren = parent.Children
	}
	child := parentChildren[e]
	if child == nil {
	var err error
	if parent != nil {
	child, err = parent.addChild(e)
	if err != nil {
	return err
	}
	} else {
	child = &YCfgNode{Name: e}
	parentChildren[e] = child
	}
	}

	if i == len(elems)-1 {
	child.Overwrite = overwrite
	child.Value = val
	}

	parent = child
	}

	return nil
	}

	func NewYCfg(kv map[string]interface{}) (YCfg, error) {
	yc := YCfg{}

	for k, v := range kv {
	if err := yc.Replace(k, v); err != nil {
	return nil, err
	}
	}

	return yc, nil
	}

	func (yc YCfg) find(key string) *YCfgNode {
	elems := strings.Split(key, ".")
	if len(elems) == 0 {
	return nil
	}

	cur := &YCfgNode{
	Children: yc,
	}
	for _, e := range elems {
	if cur.Children == nil {
	return nil
	}

	cur = cur.Children[e]
	if cur == nil {
	return nil
	}
	}

	return cur
	}

	func (yc YCfg) Get(key string, settings map[string]string) []YCfgEntry {
	node := yc.find(key)
	if node == nil {
	return nil
	}

	entries := []YCfgEntry{}

	if node.Value != nil {
	entry := YCfgEntry{Value: node.Value}
	entries = append(entries, entry)
	}

	for _, child := range node.Children {
	val, err := parse.ParseAndEval(child.Name, settings)
	if err != nil {
	log.Error(err.Error())
	} else if val {
	entry := YCfgEntry{
	Value: child.Value,
	Expr: child.Name,
	}
	if child.Overwrite {
	return []YCfgEntry{entry}
	}

	entries = append(entries, entry)
	}
	}

	return entries
	}

	func (yc YCfg) GetSlice(key string, settings map[string]string) []YCfgEntry {
	sliceEntries := yc.Get(key, settings)
	if len(sliceEntries) == 0 {
	return nil
	}

	result := []YCfgEntry{}
	for _, sliceEntry := range sliceEntries {
	if sliceEntry.Value != nil {
	slice, err := cast.ToSliceE(sliceEntry.Value)
	if err != nil {
	// Not a slice. Put the single value in a new slice.
	slice = []interface{}{sliceEntry.Value}
	}
	for _, v := range slice {
	entry := YCfgEntry{
	Value: v,
	Expr: sliceEntry.Expr,
	}
	result = append(result, entry)
	}
	}
	}

	return result
	}

	func (yc YCfg) GetValSlice(
	key string, settings map[string]string) []interface{} {

	entries := yc.GetSlice(key, settings)
	if len(entries) == 0 {
	return nil
	}

	vals := make([]interface{}, len(entries))
	for i, e := range entries {
	vals[i] = e.Value
	}

	return vals
	}

	func (yc YCfg) GetStringSlice(key string,
	settings map[string]string) []YCfgEntry {

	sliceEntries := yc.Get(key, settings)
	if len(sliceEntries) == 0 {
	return nil
	}

	result := []YCfgEntry{}
	for _, sliceEntry := range sliceEntries {
	if sliceEntry.Value != nil {
	slice, err := cast.ToStringSliceE(sliceEntry.Value)
	if err != nil {
	// Not a slice. Put the single value in a new slice.
	slice = []string{cast.ToString(sliceEntry.Value)}
	}
	for _, v := range slice {
	entry := YCfgEntry{
	Value: v,
	Expr: sliceEntry.Expr,
	}
	result = append(result, entry)
	}
	}
	}

	return result
	}

	func (yc YCfg) GetValStringSlice(
	key string, settings map[string]string) []string {

	entries := yc.GetStringSlice(key, settings)
	if len(entries) == 0 {
	return nil
	}

	vals := make([]string, len(entries))
	for i, e := range entries {
	if e.Value != nil {
	vals[i] = cast.ToString(e.Value)
	}
	}

	return vals
	}

	func (yc YCfg) GetValStringSliceNonempty(
	key string, settings map[string]string) []string {

	strs := yc.GetValStringSlice(key, settings)
	filtered := make([]string, 0, len(strs))
	for _, s := range strs {
	if s != "" {
	filtered = append(filtered, s)
	}
	}

	return filtered
	}

	func (yc YCfg) GetStringMap(
	key string, settings map[string]string) map[string]YCfgEntry {

	mapEntries := yc.Get(key, settings)
	if len(mapEntries) == 0 {
	return nil
	}

	result := map[string]YCfgEntry{}

	for _, mapEntry := range mapEntries {
	for k, v := range cast.ToStringMap(mapEntry.Value) {
	entry := YCfgEntry{
	Value: v,
	Expr: mapEntry.Expr,
	}

	// XXX: Report collisions?
	result[k] = entry
	}
	}

	return result
	}

	func (yc YCfg) GetValStringMap(
	key string, settings map[string]string) map[string]interface{} {

	entryMap := yc.GetStringMap(key, settings)

	smap := make(map[string]interface{}, len(entryMap))
	for k, v := range entryMap {
	if v.Value != nil {
	smap[k] = v.Value
	}
	}

	return smap
	}

	func (yc YCfg) GetFirst(key string, settings map[string]string) (YCfgEntry, bool) {
	entries := yc.Get(key, settings)
	if len(entries) == 0 {
	return YCfgEntry{}, false
	}

	return entries[0], true
	}

	func (yc YCfg) GetFirstVal(key string, settings map[string]string) interface{} {
	entry, ok := yc.GetFirst(key, settings)
	if !ok {
	return nil
	}

	return entry.Value
	}

	func (yc YCfg) GetValString(key string, settings map[string]string) string {
	entry, ok := yc.GetFirst(key, settings)
	if !ok {
	return ""
	} else {
	return cast.ToString(entry.Value)
	}
	}

	func (yc YCfg) GetValInt(key string, settings map[string]string) int {
	entry, ok := yc.GetFirst(key, settings)
	if !ok {
	return 0
	} else {
	return cast.ToInt(entry.Value)
	}
	}

	func (yc YCfg) GetValBoolDflt(key string, settings map[string]string,
	dflt bool) bool {

	entry, ok := yc.GetFirst(key, settings)
	if !ok {
	return dflt
	} else {
	return cast.ToBool(entry.Value)
	}
	}

	func (yc YCfg) GetValBool(key string, settings map[string]string) bool {
	return yc.GetValBoolDflt(key, settings, false)
	}

	func (yc YCfg) GetStringMapString(key string,
	settings map[string]string) map[string]YCfgEntry {

	mapEntries := yc.Get(key, settings)
	if len(mapEntries) == 0 {
	return nil
	}

	result := map[string]YCfgEntry{}

	for _, mapEntry := range mapEntries {
	for k, v := range cast.ToStringMapString(mapEntry.Value) {
	entry := YCfgEntry{
	Value: v,
	Expr: mapEntry.Expr,
	}

	// XXX: Report collisions?
	result[k] = entry
	}
	}

	return result
	}

	func (yc YCfg) GetValStringMapString(key string,
	settings map[string]string) map[string]string {

	entryMap := yc.GetStringMapString(key, settings)

	valMap := make(map[string]string, len(entryMap))
	for k, v := range entryMap {
	if v.Value != nil {
	valMap[k] = cast.ToString(v.Value)
	}
	}

	return valMap
	}

	func (node *YCfgNode) FullName() string {
	tokens := []string{}

	for n := node; n != nil; n = n.Parent {
	tokens = append(tokens, n.Name)
	}

	last := len(tokens) - 1
	for i := 0; i < len(tokens)/2; i++ {
	tokens[i], tokens[last-i] = tokens[last-i], tokens[i]
	}

	return strings.Join(tokens, ".")
	}

	func (yc YCfg) Delete(name string) {
	delete(yc, name)
	}

	func (yc YCfg) Traverse(cb func(node *YCfgNode, depth int)) {
	var traverseLevel func(
	node *YCfgNode,
	cb func(node *YCfgNode, depth int),
	depth int)

	traverseLevel = func(
	node *YCfgNode,
	cb func(node *YCfgNode, depth int),
	depth int) {

	cb(node, depth)
	for _, child := range node.Children {
	traverseLevel(child, cb, depth+1)
	}
	}

	for _, n := range yc {
	traverseLevel(n, cb, 0)
	}
	}

	func (yc YCfg) AllSettings() map[string]interface{} {
	settings := map[string]interface{}{}

	yc.Traverse(func(node *YCfgNode, depth int) {
	if node.Value != nil {
	settings[node.FullName()] = node.Value
	}
	})

	return settings
	}

	func (yc YCfg) AllSettingsAsStrings() map[string]string {
	settings := yc.AllSettings()
	smap := make(map[string]string, len(settings))
	for k, v := range settings {
	smap[k] = fmt.Sprintf("%v", v)
	}

	return smap
	}

	func (yc YCfg) String() string {
	lines := make([]string, 0, len(yc))
	yc.Traverse(func(node *YCfgNode, depth int) {
	line := strings.Repeat(" ", depth*4) + node.Name
	if node.Value != nil {
	line += fmt.Sprintf(": %+v", node.Value)
	}
	lines = append(lines, line)
	})

	return strings.Join(lines, "\n")
	}