konfig

 var configFiles = []klfile. File {
	{
		Path :   "./config.json" ,
		Parser : kpjson . Parser ,
	},
}

func init () {
	konfig . Init ( konfig . DefaultConfig ())
}

func main () {
	// load from json file
	konfig . RegisterLoaderWatcher (
		klfile . New ( & klfile. Config {
			Files : configFiles ,
			Watch : true ,
		}),
		// optionally you can pass config hooks to run when a file is changed
		func ( c konfig . Store ) error {
			return nil
		},
	)

	if err := konfig . LoadWatch (); err != nil {
		log . Fatal ( err )
	}

	// retrieve value from config file
	konfig . Bool ( "debug" )
}

 konfig . Init ( konfig . DefaultConfig ())

 konfig . Get ( "foo" ) // calls store.Get("foo")

 s := konfig . New ( konfig . DefaultConfig ())

 if err := konfig . LoadWatch (); err != nil {
	log . Fatal ( err )
}

 if err := konfig . Load (); err != nil {
	log . Fatal ( err )
}

 if err := konfig . Watch (); err != nil {
	log . Fatal ( err )
}

 type Loader interface {
	// Name return the name of the load, it is used to create labeled vectors metrics per loader
	Name () string
	// StopOnFailure indicates if a failure of the loader should trigger a stop
	StopOnFailure () bool
	// Loads the config and add it to the Store
	Load ( Store ) error
	// MaxRetry returns the maximum number of times to allow retrying on load failure
	MaxRetry () int
	// RetryDelay returns the delay to wait before retrying
	RetryDelay () time. Duration
}

 configLoader := konfig . RegisterLoader (
	klfile . New (
		& klfile. Config {
			Files : []klfile. File {
				{
					Parser : kpjson . Parser ,
					Path :   "./ konfig .json" ,
				},
			},
		},
	),
)

 configLoader := konfig . RegisterLoaderWatcher (
	klfile . New (
		& klfile. Config {
			Files : []klfile. File {
				{
					Parser : kpjson . Parser ,
					Path :   "./ konfig .json" ,
				},
			},
			Watch : true ,
		},
	),
)

 configLoader := konfig . RegisterLoaderWatcher (
	// it creates a LoaderWatcher from a loader and a watcher
	konfig . NewLoaderWatcher (
		someLoader ,
		someWatcher ,
	),
)

 type Watcher interface {
	// Start starts the watcher, it must not be blocking.
	Start () error
	// Done indicate whether the watcher is done or not
	Done () <- chan struct {}
	// Watch should block until an event unlocks it
	Watch () <- chan struct {}
	// Close closes the watcher, it returns a non nil error if it is already closed
	// or something prevents it from closing properly.
	Close () error
	// Err returns the error attached to the watcher
	Err () error
}

 configLoader := konfig . RegisterLoaderWatcher (
	klfile . New (
		& klfile. Config {
			Files : []klfile. File {
				{
					Parser : kpyaml . Parser ,
					Path :   "./ konfig .yaml" ,
				},
			},
			Watch : true ,
		},
	),
	func ( s konfig . Store ) error {
		// Here you should reload the state of your app
		return nil
	},
)

 configLoader . AddHooks (
	func ( s konfig . Store ) error {
		// Here you should reload the state of your app
		return nil
	},
	func ( s konfig . Store ) error {
		// Here you should reload the state of your app
		return nil
	},
)

 konfig . RegisterKeyHook (
	"db." ,
	func ( s konfig . Store ) error {
		return nil
	},
)

 type Closer interface {
	Close () error
}

 konfig . RegisterCloser ( closer )

 konfig . Group ( "db" ). RegisterLoaderWatcher (
	klfile . New (
		& klfile. Config {
			Files : []klfile. File {
				{
					Parser : kpyaml . Parser ,
					Path :   "./db.yaml" ,
				},
			},
			Watch : true ,
		},
	),
)

// accessing grouped config
dbHost := konfig . Group ( "db" ). MustString ( "credentials.host" )

 type DBConfig struct {
	Username string
}
type Config struct {
	Addr      string
	Debug     string
	DB        DBConfig ` konfig :"db"`
	RedisHost string   ` konfig :"redis.host"`
}

// we init the root konfig store
konfig . Init ( konfig . DefaultConfig ())

// we bind the Config struct to the konfig .Store
konfig . Bind ( Config {})

// we register our config file
konfig . RegisterLoaderWatcher (
	klfile . New (
		& klfile. Config {
			Files : []klfile. File {
				{
					Parser : kpjson . Parser ,
					Path :   "./config.json" ,
				},
			},
			Watch : true ,
		},
	),
)

// we load our config and start watching
if err := konfig . LoadWatch (); err != nil {
	log . Fatal ( err )
}

// Get our config value
c := konfig . Value ().( Config )

fmt . Println ( c . Addr ) // :8080

 // Exists checks whether the key k is set in the store.
Exists ( k string ) bool

// Get gets the value with the key k from the store. If the key is not set, Get returns nil. To check whether a value is really set, use Exists.
Get ( k string ) interface {}
// MustGet tries to get the value with the key k from the store. If the key k does not exist in the store, MustGet panics.
MustGet ( k string ) interface {}

// MustString tries to get the value with the key k from the store and casts it to a string. If the key k does not exist in the store, MustString panics.
MustString ( k string ) string
// String tries to get the value with the key k from the store and casts it to a string. If the key k does not exist it returns the Zero value.
String ( k string ) string

// MustInt tries to get the value with the key k from the store and casts it to a int. If the key k does not exist in the store, MustInt panics.
MustInt ( k string ) int
// Int tries to get the value with the key k from the store and casts it to a int. If the key k does not exist it returns the Zero value.
Int ( k string ) int

// MustFloat tries to get the value with the key k from the store and casts it to a float. If the key k does not exist in the store, MustFloat panics.
MustFloat ( k string ) float64
// Float tries to get the value with the key k from the store and casts it to a float. If the key k does not exist it returns the Zero value.
Float ( k string ) float64

// MustBool tries to get the value with the key k from the store and casts it to a bool. If the key k does not exist in the store, MustBool panics.
MustBool ( k string ) bool
// Bool tries to get the value with the key k from the store and casts it to a bool. If the key k does not exist it returns the Zero value.
Bool ( k string ) bool

// MustDuration tries to get the value with the key k from the store and casts it to a time.Duration. If the key k does not exist in the store, MustDuration panics.
MustDuration ( k string ) time . Duration
// Duration tries to get the value with the key k from the store and casts it to a time.Duration. If the key k does not exist it returns the Zero value.
Duration ( k string ) time . Duration

// MustTime tries to get the value with the key k from the store and casts it to a time.Time. If the key k does not exist in the store, MustTime panics.
MustTime ( k string ) time . Time
// Time tries to get the value with the key k from the store and casts it to a time.Time. If the key k does not exist it returns the Zero value.
Time ( k string ) time . Time

// MustStringSlice tries to get the value with the key k from the store and casts it to a []string. If the key k does not exist in the store, MustStringSlice panics.
MustStringSlice ( k string ) [] string
// StringSlice tries to get the value with the key k from the store and casts it to a []string. If the key k does not exist it returns the Zero value.
StringSlice ( k string ) [] string

// MustIntSlice tries to get the value with the key k from the store and casts it to a []int. If the key k does not exist in the store, MustIntSlice panics.
MustIntSlice ( k string ) [] int
// IntSlice tries to get the value with the key k from the store and casts it to a []int. If the key k does not exist it returns the Zero value.
IntSlice ( k string ) [] int

// MustStringMap tries to get the value with the key k from the store and casts it to a map[string]interface{}. If the key k does not exist in the store, MustStringMap panics.
MustStringMap ( k string ) map [ string ] interface {}
// StringMap tries to get the value with the key k from the store and casts it to a map[string]interface{}. If the key k does not exist it returns the Zero value.
StringMap ( k string ) map [ string ] interface {}

// MustStringMapString tries to get the value with the key k from the store and casts it to a map[string]string. If the key k does not exist in the store, MustStringMapString panics.
MustStringMapString ( k string ) map [ string ] string
// StringMapString tries to get the value with the key k from the store and casts it to a map[string]string. If the key k does not exist it returns the Zero value.
StringMapString ( k string ) map [ string ] string

 debug := konfig . Getter ( "debug" )

debug . Bool () // true

 konfig . Init ( & konfig . Config {
	Metrics : true ,
	Name : "root" ,
})