cnfg

Complete working example for UnmarshalENV(). Use this method when the "xml" struct tag suits your application.

package main

import (
	"fmt"
	"os"

	"golift.io/cnfg"
)

func main() {
	// Systems is used to show an example of how to access nested slices.
	type System struct {
		Name   string             `xml:"name"`
		Signal []byte             `xml:"signal"`
		Ion    *map[string]string `xml:"ion"`
	}

	// Config represents your application's environment variable based config inputs.
	// Works with or without pointers.
	type Config struct {
		Users []struct {
			Name   string    `xml:"name"`
			Levels []float64 `xml:"level"`
		} `xml:"user"`
		Systems []*System `xml:"system"`
	}

	// Make a pointer to your struct. It may be empty or contain defaults.
	// It may contain nested pointers, structs, maps, slices, etc. It all works.
	config := &Config{}

	// Okay set some ENV variables. Pretend you did this in bash.
	// Setting these will overwrite any existing data. If you set a slice that
	// does not exist, it has to be the _following_ index number. In other words,
	// if your slice is empty, setting APP_USER_1_NAME wont work, you have to start
	// with 0. If your slice len is 2, you can append by setting APP_USER_2_NAME
	os.Setenv("APP_USER_0_NAME", "Tim")
	os.Setenv("APP_USER_0_LEVEL_0", "1")
	os.Setenv("APP_USER_0_LEVEL_1", "13")
	os.Setenv("APP_USER_1_NAME", "Jon")
	os.Setenv("APP_USER_1_LEVEL_0", "1")

	// This adds (creates) systems and signals in sub-slices.
	os.Setenv("APP_SYSTEM_0_NAME", "SysWon")
	os.Setenv("APP_SYSTEM_1_NAME", "SysToo")
	// With []byte you can only pass a string, and it's converted.
	// You cannot access a byte member directly. Do you need to? Let me know!
	os.Setenv("APP_SYSTEM_0_SIGNAL", "123456")
	os.Setenv("APP_SYSTEM_1_SIGNAL", "654321")

	// Maps inside slices! You can nest all you want, but your variable names may get lengthy.
	fmt.Printf("BEFORE => Users: %v, Systems: %v\n", len(config.Users), len(config.Systems))
	os.Setenv("APP_SYSTEM_1_ION_reactor-1", "overload")
	os.Setenv("APP_SYSTEM_1_ION_reactor-2", "underload")

	// Run Unmarshal to parse the values into your config pointer.
	// We ignore "ok" here. You may choose to capture and it do something though.
	_, err := cnfg.UnmarshalENV(config, "APP")
	if err != nil {
		panic(err)
	}

	fmt.Printf("AFTER  => Users: %v\n", config.Users)

	for i, s := range config.Systems {
		fmt.Printf(" %v: System Name: %v, Signals: %v, Ion: %v\n", i, s.Name, s.Signal, s.Ion)
	}
}

Output:

BEFORE => Users: 0, Systems: 0
AFTER  => Users: [{Tim [1 13]} {Jon [1]}]
 0: System Name: SysWon, Signals: [49 50 51 52 53 54], Ion: <nil>
 1: System Name: SysToo, Signals: [54 53 52 51 50 49], Ion: &map[reactor-1:overload reactor-2:underload]

package main

import (
	"fmt"

	"golift.io/cnfg"
)

func main() {
	type myConfig struct {
		Key    string `xml:"envkey"`
		Key2   string `xml:"envkey2"`
		Nested struct {
			SubSlice []string          `xml:"subslice"`
			SubMap   map[string]string `xml:"submap"`
		} `xml:"nested"`
	}

	// Create a pointer to unmarshal your map into.
	config := &myConfig{}

	// Generally you'd use MapEnvPairs() to create a map from a slice of []string.
	// You can also get your data from any other source, as long as it can be
	// formatted into a map.
	// The important part is formatting the map keys correctly. The struct tag names
	// are always upcased, but nested struct member maps are not. They can be any case.
	// Each nested struct is appended to the parent name(s) with an underscore _.
	// Slices (except byte slices) are accessed by their position, beginning with 0.
	pairs := make(cnfg.Pairs)
	pairs["ENVKEY"] = "some env value"
	pairs["ENVKEY2"] = "some other env value"
	pairs["NESTED_SUBSLICE_0"] = "first slice value"
	pairs["NESTED_SUBMAP_mapKey"] = "first map key value"

	worked, err := cnfg.UnmarshalMap(pairs, config)
	if err != nil {
		panic(err)
	}

	fmt.Printf("ok: %v, key: %v, key2: %v\n", worked, config.Key, config.Key2)
	fmt.Println("map:", config.Nested.SubMap)
	fmt.Println("slice:", config.Nested.SubSlice)
}

Output:

ok: true, key: some env value, key2: some other env value
map: map[mapKey:first map key value]
slice: [first slice value]