func (e EnvTree) GetFloatUnsecured() float32 {
	if val, err := getFloat(getRootValue(e)); err == nil {
		return val
	}
	return 0
}
GetFloatUnsecured is insecured version of GetFloat to avoid the burden
of rechecking errors if it was done already. If any errors occurred cause
the variable is missing or not a floating value, it returns default zero floating value.
This function has to be used carefully
package envh
import (
	"regexp"
	"strings"
)
type EnvTree struct {
	root *node
}
func NewEnvTree(reg string, delimiter string) (EnvTree, error) {
	r, err := regexp.Compile(reg)
	if err != nil {
		return EnvTree{}, err
	}
	t := createTreeFromDelimiterFilteringByRegexp(r, delimiter)
	return EnvTree{t}, nil
}
func (e EnvTree) FindString(keyChain ...string) (string, error) {
	return getString(getNodeValueByKeyChain(e.root, &keyChain))
}
func (e EnvTree) FindStringUnsecured(keyChain ...string) string {
	if val, err := getString(getNodeValueByKeyChain(e.root, &keyChain)); err == nil {
		return val
	}
	return ""
}
func (e EnvTree) FindInt(keyChain ...string) (int, error) {
	return getInt(getNodeValueByKeyChain(e.root, &keyChain))
}
func (e EnvTree) FindIntUnsecured(keyChain ...string) int {
	if val, err := getInt(getNodeValueByKeyChain(e.root, &keyChain)); err == nil {
		return val
	}
	return 0
}
func (e EnvTree) FindFloat(keyChain ...string) (float32, error) {
	return getFloat(getNodeValueByKeyChain(e.root, &keyChain))
}
func (e EnvTree) FindFloatUnsecured(keyChain ...string) float32 {
	if val, err := getFloat(getNodeValueByKeyChain(e.root, &keyChain)); err == nil {
		return val
	}
	return 0
}
func (e EnvTree) FindBool(keyChain ...string) (bool, error) {
	return getBool(getNodeValueByKeyChain(e.root, &keyChain))
}
func (e EnvTree) FindBoolUnsecured(keyChain ...string) bool {
	if val, err := getBool(getNodeValueByKeyChain(e.root, &keyChain)); err == nil {
		return val
	}
	return false
}
func (e EnvTree) IsExistingSubTree(keyChain ...string) bool {
	_, exists := e.root.findNodeByKeyChain(&keyChain)
	return exists
}
func (e EnvTree) HasSubTreeValue(keyChain ...string) (bool, error) {
	n, exists := e.root.findNodeByKeyChain(&keyChain)
	if !exists {
		return false, NodeNotFoundError{keyChain}
	}
	return n.hasValue, nil
}
func (e EnvTree) HasSubTreeValueUnsecured(keyChain ...string) bool {
	n, exists := e.root.findNodeByKeyChain(&keyChain)
	if !exists {
		return false
	}
	return n.hasValue
}
func (e EnvTree) FindSubTree(keyChain ...string) (EnvTree, error) {
	if n, exists := e.root.findNodeByKeyChain(&keyChain); exists {
		return EnvTree{n}, nil
	}
	return EnvTree{}, NodeNotFoundError{keyChain}
}
func (e EnvTree) FindSubTreeUnsecured(keyChain ...string) EnvTree {
	if n, exists := e.root.findNodeByKeyChain(&keyChain); exists {
		return EnvTree{n}
	}
	return EnvTree{}
}
func (e EnvTree) FindChildrenKeys(keyChain ...string) ([]string, error) {
	n, exists := e.root.findNodeByKeyChain(&keyChain)
	if !exists {
		return []string{}, NodeNotFoundError{keyChain}
	}
	keys := []string{}
	for _, c := range n.children {
		keys = append(keys, c.key)
	}
	return keys, nil
}
func (e EnvTree) FindChildrenKeysUnsecured(keyChain ...string) []string {
	n, exists := e.root.findNodeByKeyChain(&keyChain)
	if !exists {
		return []string{}
	}
	keys := []string{}
	for _, c := range n.children {
		keys = append(keys, c.key)
	}
	return keys
}
func (e EnvTree) GetChildrenKeys() []string {
	keys := []string{}
	for _, c := range e.root.children {
		keys = append(keys, c.key)
	}
	return keys
}
func (e EnvTree) GetString() (string, error) {
	return getString(getRootValue(e))
}
func (e EnvTree) GetStringUnsecured() string {
	if val, err := getString(getRootValue(e)); err == nil {
		return val
	}
	return ""
}
func (e EnvTree) GetInt() (int, error) {
	return getInt(getRootValue(e))
}
func (e EnvTree) GetIntUnsecured() int {
	if val, err := getInt(getRootValue(e)); err == nil {
		return val
	}
	return 0
}
func (e EnvTree) GetFloat() (float32, error) {
	return getFloat(getRootValue(e))
}