110 lines
3.3 KiB
Go
110 lines
3.3 KiB
Go
// module conf
|
|
//
|
|
// import "code.uint32.ru/tiny/conf"
|
|
//
|
|
// Module conf implements a very simple config parser with two types of
|
|
// values: key value pairs and single word options. Each of these must be
|
|
// put on separate line in a file like this:
|
|
//
|
|
// key1 = value
|
|
// key2 = value1, value2, value3
|
|
// key3=v1,v2,v3
|
|
// option1
|
|
// option2
|
|
//
|
|
// Values can also be read from any io.Reader or io.ReadCloser. Note that
|
|
// values in key value pairs mey either be separated with spaces or not.
|
|
// Typical use case would look like this:
|
|
//
|
|
// config, err := conf.ParseFile("filename")
|
|
// if err != nil {
|
|
// // Means we failed to read from file
|
|
// // config variable is now nil and unusable
|
|
// }
|
|
// value, err := config.Find("mykey")
|
|
// if err != nil {
|
|
// // Means that key has not been found
|
|
// }
|
|
// // value now holds conf.Setting.
|
|
// n, err := value.Float64() // tries to parse float from Setting.Value field.
|
|
// //if err is nil then n holds float64.
|
|
//
|
|
// There is also a quicker Get() method which returns no errors
|
|
// ("i'm feeling lucky" way to lookup values). If it does not find
|
|
// requested key, the returned Setting has empty string in Value field.
|
|
//
|
|
// value2 := config.Get("otherkey")
|
|
// mybool, err := value2.Bool() // tries to interpret Setting.Value field as bool
|
|
// // mybool now holds boolean if "otherkey" was found and error returned
|
|
// // by Bool() method is nil.
|
|
//
|
|
// Even shorter syntax would be:
|
|
//
|
|
// listnumbers, err := config.Get("numbers").IntSlice()
|
|
// // Note that we'd still like to check for errors even if
|
|
// // we're sure the key exists to make sure all values are converted.
|
|
// // listnumbers holds slice of ints. If err is nil all of found values
|
|
// // have been converted successfully.
|
|
//
|
|
// To check whether single-word options were found use:
|
|
//
|
|
// if config.HasOption("wordoption") {
|
|
// // do something
|
|
// }
|
|
//
|
|
// See description of module's other methods which are
|
|
// quite self-explanatory.
|
|
package conf
|
|
|
|
// Config holds parsed keys and values. Settings and Options can be
|
|
// accessed with Config.Settings and Config.Options maps directly.
|
|
type Config struct {
|
|
// Settings store key value pairs ("key = value" in config file)
|
|
// all key value pairs found when parsing input are accumulated in this map.
|
|
Settings map[string]string
|
|
// Options map stores single word options ("option" in config file)
|
|
Options map[string]struct{}
|
|
}
|
|
|
|
// Find looks up a Setting and returns it. If returned error is not nil
|
|
// the requested key was not found and returned Setting has empty string in Value
|
|
// field.
|
|
func (c *Config) Find(key string) (s Setting, err error) {
|
|
v, ok := c.Settings[key]
|
|
if !ok {
|
|
err = ErrNotFound
|
|
}
|
|
s.Value = v
|
|
return
|
|
}
|
|
|
|
// Get returns a Setting. If key was not found the returned Setting Value
|
|
// will be empty string.
|
|
func (c *Config) Get(key string) (s Setting) {
|
|
s.Value = c.Settings[key]
|
|
return
|
|
}
|
|
|
|
// GetDefault looks up a Setting with requested key.
|
|
// If lookup fails it returns Setting with Value field set to def.
|
|
func (c *Config) GetDefault(key, def string) (s Setting) {
|
|
v, ok := c.Settings[key]
|
|
switch ok {
|
|
case true:
|
|
s.Value = v
|
|
default:
|
|
s.Value = def
|
|
}
|
|
return
|
|
}
|
|
|
|
// HasOption returns true if line:
|
|
//
|
|
// "key"
|
|
//
|
|
// was found in the parsed file
|
|
func (c *Config) HasOption(option string) (exists bool) {
|
|
_, exists = c.Options[option]
|
|
return
|
|
}
|