Determine if struct is initialised

If I have a hypothetical struct:

type Config struct {
        Server struct {
                Host string
                Port uint16
                Timeout uint32
        }
}

I want to know whether the Host and the Port are set or are defaulting (Host to "" and Port or Timeout to 0). Is there an efficient way to do this? Potentially using the reflect library?

Also, I am assuming that "" and 0 are valid entries.

Some background: I am using the gcfg library to read an INI style config file and want to know if someone has not set one of the configuration entries.

You can't do that. At least if my understanding of your problem is correct:

You want to know e.g. if someone intentionally set Timeout = 0 or whether Timeout is zero because the runtime initialized Timeout to the zero value of uint32?

If 0 is stored in this uint32 you cannot distinguish between "This 0 was set by some user by executing Timeout = 0." and "This 0 was set by the runtime during initializing the structure." There is just one 0 and this 0 has no history.

If you need to tell the difference you could change Timeout uint32 to Timeout *uint32: The runtime initializes Timeout to nil. If Timeout is non-nil its was set. (But this comes with the obvious price of nil checks everywhere, additional error handling and complicated handling.)

I guess you're using gcfg - I had a very similar question when I started using gcfg. My solution was to load my defaults explicitly, then load the file(s) over them.

Here's mine; enjoy.

Not a direct answer but a common alternative to this kind of problems:

Use a nil-pointer to represent a reference to an uninitialized structure. You'll need a pointer anyways if you plan to pass the structure to an ini parser

The ini parser (or any parser that uses reflection) will not touch the passed pointer unless it can parse something, in which case it will create a new instance of the pointed-to type and change the pointer to target the newly parsed data structure.

http://play.golang.org/p/VkkXSuqbhi

package main

import "fmt"

type Config struct {
	Server struct {
		Host    string
		Port    uint16
		Timeout uint32
	}
}

func main() {
	var c *Config
	fmt.Println(nil == c)
	c = &Config{}
	fmt.Println(nil == c)
}

The following would probably add more complexity than you want but, just so you're aware of all the options:

Gcfg's documentation claims(I haven't actually done it myself) that it provides one more alternative, by way of the fmt.Scanner interface. Any named type that you declare can be parsed from the INI file, so long as it implements fmt.Scanner.

With this in mind, you could, if you felt like it, do something along the lines of the following:

package main
import (
    "fmt"
    "strconv"
    "strings"
)
type OptionalInt struct {
	IsSet bool
	Value int
}

//This method definition is rather impromptu and may not be the best way to scan an int
func (optInt *OptionalInt) Scan (state fmt.ScanState, verb rune) (err error) {
	var token []byte
	var n int
	token, err = state.Token(true, nil)
	if err==nil {
		n, err = strconv.Atoi(string(token))
		if err==nil{
			optInt.Value = n
			optInt.IsSet = true
		}
	}
	return
}

type Config struct {
	Port OptionalInt
	TimeOut OptionalInt
}

func main(){
    //whatever...
}

If you do this then, once you've loaded all the data from the INI file into your Config structure, the data will appear in a set of OptionalInt fields. And for each such field, you will be able to check IsSet, as well as the Value inside.

If this approach appeals to you and you end up trying it, maybe you could post a comment here so that the rest of us will know how it works out.

Get rid of gcfg and use standard go flags with iniflags. This will allow you removing a bunch of hackish code mentioned in other answers and make your go code more idiomatic, while supporting default values and descriptions for each config value out-of-the-box.