type Registrator interface {
	Register()
}

type Struct struct {
	sync.Mutex
	Nested map[string]Registrator
}

func register(v reflect.Value) bool {
	c, ok := v.Interface().(Registrator)
	if ok {
		c.Register()
	}

	return ok
}

func RegisterRecursively(value interface{}) {
	val := reflect.ValueOf(value)
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}

	if val.Kind() != reflect.Struct {
		return
	}

	if _, ok := val.Interface().(Struct); ok {
		// A Struct handles registration on its own
		return
	}

	for i := 0; i < val.NumField(); i++ {
		field := val.Field(i)
		if !field.CanInterface() {
			continue
		}

		if register(field) {
			continue
		}

		if field.Kind() == reflect.Ptr {
			field = field.Elem()
		}

		switch field.Kind() {
		case reflect.Map:
			for _, item := range field.MapKeys() {
				register(field.MapIndex(item))
			}
		case reflect.Struct:
			RegisterRecursively(val.Field(i).Interface())
		}
	}
}

	if val.Kind() == reflect.Ptr {
		if val.Type() == reflect.TypeOf((*Struct)(nil)) {
			// A *Struct handles registration on its own.
			return
		}
		val = val.Elem()
	}