get.go

package conf

import (
	"strconv"
	"strings"
    "reflect"
)

// GetSections returns the list of sections in the configuration.
// (The default section always exists.)
func (c *ConfigFile) GetSections() (sections []string) {
	sections = make([]string, len(c.data))

	i := 0
	for s, _ := range c.data {
		sections[i] = s
		i++
	}

	return sections
}

// HasSection checks if the configuration has the given section.
// (The default section always exists.)
func (c *ConfigFile) HasSection(section string) bool {
	if section == "" {
		section = "default"
	}
	_, ok := c.data[strings.ToLower(section)]

	return ok
}

// GetOptions returns the list of options available in the given section.
// It returns an error if the section does not exist and an empty list if the section is empty.
// Options within the default section are also included.
func (c *ConfigFile) GetOptions(section string) (options []string, err error) {
	if section == "" {
		section = "default"
	}
	section = strings.ToLower(section)

	if _, ok := c.data[section]; !ok {
		return nil, GetError{SectionNotFound, "", "", section, ""}
	}

	options = make([]string, len(c.data[DefaultSection])+len(c.data[section]))
	i := 0
	for s, _ := range c.data[DefaultSection] {
		options[i] = s
		i++
	}
	for s, _ := range c.data[section] {
		options[i] = s
		i++
	}

	return options, nil
}

// HasOption checks if the configuration has the given option in the section.
// It returns false if either the option or section do not exist.
func (c *ConfigFile) HasOption(section string, option string) bool {
	if section == "" {
		section = "default"
	}
	section = strings.ToLower(section)
	option = strings.ToLower(option)

	if _, ok := c.data[section]; !ok {
		return false
	}

	_, okd := c.data[DefaultSection][option]
	_, oknd := c.data[section][option]

	return okd || oknd
}

// GetRawString gets the (raw) string value for the given option in the section.
// The raw string value is not subjected to unfolding, which was illustrated in the beginning of this documentation.
// It returns an error if either the section or the option do not exist.
func (c *ConfigFile) GetRawString(section string, option string) (value string, err error) {
	if section == "" {
		section = "default"
	}

	section = strings.ToLower(section)
	option = strings.ToLower(option)

	if _, ok := c.data[section]; ok {
		if value, ok = c.data[section][option]; ok {
			return value, nil
		}
		return "", GetError{OptionNotFound, "", "", section, option}
	}
	return "", GetError{SectionNotFound, "", "", section, option}
}

// GetString gets the string value for the given option in the section.
// If the value needs to be unfolded (see e.g. %(host)s example in the beginning of this documentation),
// then GetString does this unfolding automatically, up to DepthValues number of iterations.
// It returns an error if either the section or the option do not exist, or the unfolding cycled.
func (c *ConfigFile) GetString(section string, option string) (value string, err error) {
	value, err = c.GetRawString(section, option)
	if err != nil {
		return "", err
	}

	return value, nil
}

// GetInt has the same behaviour as GetString but converts the response to int.
func (c *ConfigFile) GetInt(section string, option string) (value int, err error) {
	sv, err := c.GetString(section, option)
	if err == nil {
		value, err = strconv.Atoi(sv)
		if err != nil {
			err = GetError{CouldNotParse, "int", sv, section, option}
		}
	}

	return value, err
}

// GetFloat has the same behaviour as GetString but converts the response to float.
func (c *ConfigFile) GetFloat64(section string, option string) (value float64, err error) {
	sv, err := c.GetString(section, option)
	if err == nil {
		value, err = strconv.ParseFloat(sv, 64)
		if err != nil {
			err = GetError{CouldNotParse, "float64", sv, section, option}
		}
	}

	return value, err
}

// GetBool has the same behaviour as GetString but converts the response to bool.
// See constant BoolStrings for string values converted to bool.
func (c *ConfigFile) GetBool(section string, option string) (value bool, err error) {
	sv, err := c.GetString(section, option)
	if err != nil {
		return false, err
	}

	value, ok := BoolStrings[strings.ToLower(sv)]
	if !ok {
		return false, GetError{CouldNotParse, "bool", sv, section, option}
	}

	return value, nil
}

func (c *ConfigFile) String(option string, value string) (string) {
    if c.HasOption("default", option) {
        value, _ = c.GetString("default", option)
    }
    return value
}

func (c *ConfigFile) Int(option string, value int) (int) {
    if c.HasOption("default", option) {
        value, _ = c.GetInt("default", option)
    }
    return value
}

func (c *ConfigFile) Float64(option string, value float64) (float64) {
    if c.HasOption("default", option) {
        value, _ = c.GetFloat64("default", option)
    }
    return value
}

func (c *ConfigFile) Bool(option string, value bool) (bool) {
    if c.HasOption("default", option) {
        value, _ = c.GetBool("default", option)
    }
    return value
}

// Sets the struct primitive values as the option values in section
func (c *ConfigFile) GetStruct(section string, obj interface{}) {
    ref := reflect.ValueOf(obj).Elem()
    for i := 0; i < ref.NumField(); i++ {
        field := ref.Field(i)
        name := ref.Type().Field(i).Name
        if c.HasOption(section, name) && field.CanSet() {
            switch field.Type().Name() {
                case "bool":
                    field.SetBool(c.Bool(name, field.Bool()))
                case "string":
                    field.SetString(c.String(name, field.String()))
                case "float64":
                    field.SetFloat(c.Float64(name, field.Float()))
                case "int":
                    field.SetInt(int64(c.Int(name, int(field.Int()))))
                case "uint":
                    field.SetUint(uint64(c.Int(name, int(field.Uint()))))
            }
        }
    }
}

func (c *ConfigFile) Struct(obj interface{}) {
    c.GetStruct("default", obj)
}