Compare commits
No commits in common. "b90103646712b7398adeb7f59d34c52a9daba24a" and "9badf9a54a3468409ebcf78d7638cf2aba73e43a" have entirely different histories.
b901036467
...
9badf9a54a
@ -1,916 +0,0 @@
|
||||
package envconf
|
||||
|
||||
import "time"
|
||||
|
||||
type mapEnvType [5]*keyLookupType
|
||||
|
||||
func (c *Config) GetMapInt(key string) (empty map[string]int64) {
|
||||
empty = make(map[string]int64)
|
||||
retval := make(map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMetric(key string) (empty map[string]int64) {
|
||||
empty = make(map[string]int64)
|
||||
retval := make(map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapDuration(key string) (empty map[string]time.Duration) {
|
||||
empty = make(map[string]time.Duration)
|
||||
retval := make(map[string]time.Duration)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.durval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapString(key string) (empty map[string]string) {
|
||||
empty = make(map[string]string)
|
||||
retval := make(map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapDirectory(key string) (empty map[string]string) {
|
||||
empty = make(map[string]string)
|
||||
retval := make(map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapBool(key string) (empty map[string]bool) {
|
||||
empty = make(map[string]bool)
|
||||
retval := make(map[string]bool)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.boolval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapHex(key string) (empty map[string][]byte) {
|
||||
empty = make(map[string][]byte)
|
||||
retval := make(map[string][]byte)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[0].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
entry := c.env[v11.key]
|
||||
if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11] = entry.parsed.binval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapInt(key string) (empty map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMetric(key string) (empty map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapDuration(key string) (empty map[string]map[string]time.Duration) {
|
||||
empty = make(map[string]map[string]time.Duration)
|
||||
retval := make(map[string]map[string]time.Duration)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]time.Duration)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.durval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapString(key string) (empty map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]string)
|
||||
retval := make(map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapDirectory(key string) (empty map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]string)
|
||||
retval := make(map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapBool(key string) (empty map[string]map[string]bool) {
|
||||
empty = make(map[string]map[string]bool)
|
||||
retval := make(map[string]map[string]bool)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]bool)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.boolval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapHex(key string) (empty map[string]map[string][]byte) {
|
||||
empty = make(map[string]map[string][]byte)
|
||||
retval := make(map[string]map[string][]byte)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[1].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string][]byte)
|
||||
for k12, v12 := range v11.next {
|
||||
entry := c.env[v12.key]
|
||||
if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12] = entry.parsed.binval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapInt(key string) (empty map[string]map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]int64)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMetric(key string) (empty map[string]map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]int64)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapDuration(key string) (empty map[string]map[string]map[string]time.Duration) {
|
||||
empty = make(map[string]map[string]map[string]time.Duration)
|
||||
retval := make(map[string]map[string]map[string]time.Duration)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]time.Duration)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]time.Duration)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.durval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapString(key string) (empty map[string]map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]map[string]string)
|
||||
retval := make(map[string]map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]string)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapDirectory(key string) (empty map[string]map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]map[string]string)
|
||||
retval := make(map[string]map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]string)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapBool(key string) (empty map[string]map[string]map[string]bool) {
|
||||
empty = make(map[string]map[string]map[string]bool)
|
||||
retval := make(map[string]map[string]map[string]bool)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]bool)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]bool)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.boolval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapHex(key string) (empty map[string]map[string]map[string][]byte) {
|
||||
empty = make(map[string]map[string]map[string][]byte)
|
||||
retval := make(map[string]map[string]map[string][]byte)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[2].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string][]byte)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string][]byte)
|
||||
for k13, v13 := range v12.next {
|
||||
entry := c.env[v13.key]
|
||||
if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13] = entry.parsed.binval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapInt(key string) (empty map[string]map[string]map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]int64)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]int64)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMetric(key string) (empty map[string]map[string]map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]int64)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]int64)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapDuration(key string) (empty map[string]map[string]map[string]map[string]time.Duration) {
|
||||
empty = make(map[string]map[string]map[string]map[string]time.Duration)
|
||||
retval := make(map[string]map[string]map[string]map[string]time.Duration)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]time.Duration)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]time.Duration)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]time.Duration)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.durval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapString(key string) (empty map[string]map[string]map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]map[string]map[string]string)
|
||||
retval := make(map[string]map[string]map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]string)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]string)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapDirectory(key string) (empty map[string]map[string]map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]map[string]map[string]string)
|
||||
retval := make(map[string]map[string]map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]string)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]string)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapBool(key string) (empty map[string]map[string]map[string]map[string]bool) {
|
||||
empty = make(map[string]map[string]map[string]map[string]bool)
|
||||
retval := make(map[string]map[string]map[string]map[string]bool)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]bool)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]bool)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]bool)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.boolval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapHex(key string) (empty map[string]map[string]map[string]map[string][]byte) {
|
||||
empty = make(map[string]map[string]map[string]map[string][]byte)
|
||||
retval := make(map[string]map[string]map[string]map[string][]byte)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[3].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string][]byte)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string][]byte)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string][]byte)
|
||||
for k14, v14 := range v13.next {
|
||||
entry := c.env[v14.key]
|
||||
if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14] = entry.parsed.binval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapInt(key string) (empty map[string]map[string]map[string]map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string]int64)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string]int64)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string]int64)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeInt.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapMetric(key string) (empty map[string]map[string]map[string]map[string]map[string]int64) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]int64)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]int64)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string]int64)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string]int64)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string]int64)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string]int64)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeMetric.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.intval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapDuration(key string) (empty map[string]map[string]map[string]map[string]map[string]time.Duration) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]time.Duration)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]time.Duration)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string]time.Duration)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string]time.Duration)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string]time.Duration)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string]time.Duration)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeDuration.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.durval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapString(key string) (empty map[string]map[string]map[string]map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string]string)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string]string)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string]string)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeString.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapDirectory(key string) (empty map[string]map[string]map[string]map[string]map[string]string) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string]string)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string]string)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string]string)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string]string)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeDirectory.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.strval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapBool(key string) (empty map[string]map[string]map[string]map[string]map[string]bool) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]bool)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]bool)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string]bool)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string]bool)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string]bool)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string]bool)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeBool.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.boolval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
func (c *Config) GetMapMapMapMapMapHex(key string) (empty map[string]map[string]map[string]map[string]map[string][]byte) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string][]byte)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string][]byte)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
v10, ok := c.mapEnv[4].next[key]
|
||||
if ok {
|
||||
for k11, v11 := range v10.next {
|
||||
retval[k11] = make(map[string]map[string]map[string]map[string][]byte)
|
||||
for k12, v12 := range v11.next {
|
||||
retval[k11][k12] = make(map[string]map[string]map[string][]byte)
|
||||
for k13, v13 := range v12.next {
|
||||
retval[k11][k12][k13] = make(map[string]map[string][]byte)
|
||||
for k14, v14 := range v13.next {
|
||||
retval[k11][k12][k13][k14] = make(map[string][]byte)
|
||||
for k15, v15 := range v14.next {
|
||||
entry := c.env[v15.key]
|
||||
if (entry.dtype.baseType() == TypeHex.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k11][k12][k13][k14][k15] = entry.parsed.binval
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
625
envconf.go
625
envconf.go
@ -20,48 +20,14 @@ type cEntry struct {
|
||||
hasdef bool // Default value is defined
|
||||
}
|
||||
|
||||
type keyLookupType struct {
|
||||
key string
|
||||
end bool
|
||||
next map[string]*keyLookupType
|
||||
}
|
||||
|
||||
func (kl *keyLookupType) setKey(parts []string, key string) {
|
||||
if len(kl.next) == 0 {
|
||||
kl.next = make(map[string]*keyLookupType)
|
||||
}
|
||||
if len(parts) > 0 {
|
||||
firstPart := parts[0]
|
||||
nextLookup, ok := kl.next[firstPart]
|
||||
if ok {
|
||||
nextLookup.setKey(parts[1:], key)
|
||||
} else {
|
||||
nextLookup := new(keyLookupType)
|
||||
nextLookup.setKey(parts[1:], key)
|
||||
kl.next[firstPart] = nextLookup
|
||||
}
|
||||
} else {
|
||||
kl.key = key
|
||||
kl.end = true
|
||||
}
|
||||
}
|
||||
|
||||
func (kl *keyLookupType) print() {
|
||||
if kl.end {
|
||||
fmt.Println(kl.key)
|
||||
fmt.Println("-----------------")
|
||||
return
|
||||
}
|
||||
for key, val := range kl.next {
|
||||
fmt.Println(key)
|
||||
val.print()
|
||||
}
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
parsed bool
|
||||
env map[string]cEntry
|
||||
mapEnv *mapEnvType
|
||||
mapEnv map[string]map[string]string
|
||||
mapMapEnv map[string]map[string]map[string]string
|
||||
mapMapMapEnv map[string]map[string]map[string]map[string]string
|
||||
mapMapMapMapEnv map[string]map[string]map[string]map[string]map[string]string
|
||||
mapMapMapMapMapEnv map[string]map[string]map[string]map[string]map[string]map[string]string
|
||||
}
|
||||
|
||||
// NewConfig returns an envconf.Config that is used to read configuration from environment variables.
|
||||
@ -71,21 +37,18 @@ func NewConfig() *Config {
|
||||
config := new(Config)
|
||||
config.parsed = false
|
||||
config.env = make(map[string]cEntry)
|
||||
|
||||
config.mapEnv = new(mapEnvType)
|
||||
for level, _ := range config.mapEnv {
|
||||
config.mapEnv[level] = new(keyLookupType)
|
||||
}
|
||||
config.mapEnv = make(map[string]map[string]string)
|
||||
config.mapMapEnv = make(map[string]map[string]map[string]string)
|
||||
config.mapMapMapEnv = make(map[string]map[string]map[string]map[string]string)
|
||||
config.mapMapMapMapEnv = make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
config.mapMapMapMapMapEnv = make(map[string]map[string]map[string]map[string]map[string]map[string]string)
|
||||
|
||||
for _, v := range os.Environ() {
|
||||
splitted := strings.SplitN(v, "=", 2)
|
||||
if len(splitted) == 2 {
|
||||
key := cleanKey(splitted[0])
|
||||
val := splitted[1]
|
||||
|
||||
splitted = strings.Split(key, "_")
|
||||
maxParts := len(splitted)
|
||||
splitted = append(splitted, make([]string, len(config.mapEnv), len(config.mapEnv))...)
|
||||
splitted = append(strings.Split(key, "_"), "", "", "", "", "", "")
|
||||
if unicode.IsLetter(getFirstRune(key)) {
|
||||
var entry cEntry
|
||||
entry.value = val
|
||||
@ -94,17 +57,63 @@ func NewConfig() *Config {
|
||||
entry.empty = false
|
||||
config.env[key] = entry
|
||||
if len(splitted) > 1 {
|
||||
for level := 0; level < len(config.mapEnv); level++ {
|
||||
for count := 0; count < maxParts-1-level; count++ {
|
||||
parts := make([]string, level+2, level+2)
|
||||
lastSplit := len(parts) - 1 + count
|
||||
|
||||
for partPos, _ := range parts {
|
||||
parts[partPos] = splitted[partPos+count]
|
||||
for count, _ := range splitted {
|
||||
if count < len(splitted)-6 {
|
||||
var p0, p1, p2, p3, p4, p5 string
|
||||
p0 = strings.Trim(strings.Join(splitted[:count], "_"), "_")
|
||||
p1 = strings.Trim(strings.Join(splitted[count:], "_"), "_")
|
||||
if len(config.mapEnv[p0]) == 0 {
|
||||
config.mapEnv[p0] = make(map[string]string)
|
||||
config.mapMapEnv[p0] = make(map[string]map[string]string)
|
||||
config.mapMapMapEnv[p0] = make(map[string]map[string]map[string]string)
|
||||
config.mapMapMapMapEnv[p0] = make(map[string]map[string]map[string]map[string]string)
|
||||
config.mapMapMapMapMapEnv[p0] = make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
}
|
||||
if p0 != "" && p1 != "" {
|
||||
config.mapEnv[p0][p1] = key
|
||||
}
|
||||
|
||||
p1 = splitted[count]
|
||||
p2 = strings.Trim(strings.Join(splitted[count+1:], "_"), "_")
|
||||
if len(config.mapMapEnv[p0][p1]) == 0 {
|
||||
config.mapMapEnv[p0][p1] = make(map[string]string)
|
||||
config.mapMapMapEnv[p0][p1] = make(map[string]map[string]string)
|
||||
config.mapMapMapMapEnv[p0][p1] = make(map[string]map[string]map[string]string)
|
||||
config.mapMapMapMapMapEnv[p0][p1] = make(map[string]map[string]map[string]map[string]string)
|
||||
}
|
||||
if p0 != "" && p1 != "" && p2 != "" {
|
||||
config.mapMapEnv[p0][p1][p2] = key
|
||||
}
|
||||
|
||||
p2 = splitted[count+1]
|
||||
p3 = strings.Trim(strings.Join(splitted[count+2:], "_"), "_")
|
||||
if len(config.mapMapMapEnv[p0][p1][p2]) == 0 {
|
||||
config.mapMapMapEnv[p0][p1][p2] = make(map[string]string)
|
||||
config.mapMapMapMapEnv[p0][p1][p2] = make(map[string]map[string]string)
|
||||
config.mapMapMapMapMapEnv[p0][p1][p2] = make(map[string]map[string]map[string]string)
|
||||
}
|
||||
if p0 != "" && p1 != "" && p2 != "" && p3 != "" {
|
||||
config.mapMapMapEnv[p0][p1][p2][p3] = key
|
||||
}
|
||||
|
||||
p3 = splitted[count+2]
|
||||
p4 = strings.Trim(strings.Join(splitted[count+3:], "_"), "_")
|
||||
if len(config.mapMapMapMapEnv[p0][p1][p2][p3]) == 0 {
|
||||
config.mapMapMapMapEnv[p0][p1][p2][p3] = make(map[string]string)
|
||||
config.mapMapMapMapMapEnv[p0][p1][p2][p3] = make(map[string]map[string]string)
|
||||
}
|
||||
if p0 != "" && p1 != "" && p2 != "" && p3 != "" && p4 != "" {
|
||||
config.mapMapMapMapEnv[p0][p1][p2][p3][p4] = key
|
||||
}
|
||||
|
||||
p4 = splitted[count+3]
|
||||
p5 = strings.Trim(strings.Join(splitted[count+4:], "_"), "_")
|
||||
if len(config.mapMapMapMapMapEnv[p0][p1][p2][p3][p4]) == 0 {
|
||||
config.mapMapMapMapMapEnv[p0][p1][p2][p3][p4] = make(map[string]string)
|
||||
}
|
||||
if p0 != "" && p1 != "" && p2 != "" && p3 != "" && p4 != "" && p5 != "" {
|
||||
config.mapMapMapMapMapEnv[p0][p1][p2][p3][p4][p5] = key
|
||||
}
|
||||
parts[0] = strings.Trim(strings.Join(splitted[:count+1], "_"), "_")
|
||||
parts[len(parts)-1] = strings.Trim(strings.Join(splitted[lastSplit:], "_"), "_")
|
||||
config.mapEnv[level].setKey(parts, key)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -135,12 +144,12 @@ func (c *Config) Define(key string, dtype DataType) {
|
||||
// Variables without a defined type will be ignored by Parse.
|
||||
func (c *Config) DefineMap(key string, dtype DataType) {
|
||||
key = cleanKey(key)
|
||||
entries, ok := c.mapEnv[0].next[key]
|
||||
entries, ok := c.mapEnv[key]
|
||||
if ok {
|
||||
for _, entry := range entries.next {
|
||||
defEntry := c.env[entry.key]
|
||||
defEntry.dtype = dtype
|
||||
c.env[entry.key] = defEntry
|
||||
for _, key = range entries {
|
||||
entry := c.env[key]
|
||||
entry.dtype = dtype
|
||||
c.env[key] = entry
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -331,6 +340,146 @@ func (c *Config) getRaw(key string, dtype DataType) (val cValue) {
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) getRawMap(key string, dtype DataType) (empty map[string]cValue) {
|
||||
empty = make(map[string]cValue)
|
||||
retval := make(map[string]cValue)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
entries, ok := c.mapEnv[key]
|
||||
|
||||
if ok {
|
||||
for k, v := range entries {
|
||||
entry := c.env[v]
|
||||
if (entry.dtype.baseType() == dtype.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k] = entry.parsed
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) getRawMapMap(key string, dtype DataType) (empty map[string]map[string]cValue) {
|
||||
empty = make(map[string]map[string]cValue)
|
||||
retval := make(map[string]map[string]cValue)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
entries, ok := c.mapMapEnv[key]
|
||||
|
||||
if ok {
|
||||
for k1, v1 := range entries {
|
||||
retval[k1] = make(map[string]cValue)
|
||||
for k2, v2 := range v1 {
|
||||
entry := c.env[v2]
|
||||
if (entry.dtype.baseType() == dtype.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k1][k2] = entry.parsed
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) getRawMapMapMap(key string, dtype DataType) (empty map[string]map[string]map[string]cValue) {
|
||||
empty = make(map[string]map[string]map[string]cValue)
|
||||
retval := make(map[string]map[string]map[string]cValue)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
entries, ok := c.mapMapMapEnv[key]
|
||||
|
||||
if ok {
|
||||
for k1, v1 := range entries {
|
||||
retval[k1] = make(map[string]map[string]cValue)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]cValue)
|
||||
for k3, v3 := range v2 {
|
||||
entry := c.env[v3]
|
||||
if (entry.dtype.baseType() == dtype.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k1][k2][k3] = entry.parsed
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) getRawMapMapMapMap(key string, dtype DataType) (empty map[string]map[string]map[string]map[string]cValue) {
|
||||
empty = make(map[string]map[string]map[string]map[string]cValue)
|
||||
retval := make(map[string]map[string]map[string]map[string]cValue)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
entries, ok := c.mapMapMapMapEnv[key]
|
||||
|
||||
if ok {
|
||||
for k1, v1 := range entries {
|
||||
retval[k1] = make(map[string]map[string]map[string]cValue)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]cValue)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]cValue)
|
||||
for k4, v4 := range v3 {
|
||||
entry := c.env[v4]
|
||||
if (entry.dtype.baseType() == dtype.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k1][k2][k3][k4] = entry.parsed
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) getRawMapMapMapMapMap(key string, dtype DataType) (empty map[string]map[string]map[string]map[string]map[string]cValue) {
|
||||
empty = make(map[string]map[string]map[string]map[string]map[string]cValue)
|
||||
retval := make(map[string]map[string]map[string]map[string]map[string]cValue)
|
||||
if c.parsed {
|
||||
key = cleanKey(key)
|
||||
entries, ok := c.mapMapMapMapMapEnv[key]
|
||||
|
||||
if ok {
|
||||
for k1, v1 := range entries {
|
||||
retval[k1] = make(map[string]map[string]map[string]map[string]cValue)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]map[string]cValue)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]map[string]cValue)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = make(map[string]cValue)
|
||||
for k5, v5 := range v4 {
|
||||
entry := c.env[v5]
|
||||
if (entry.dtype.baseType() == dtype.baseType()) && (entry.parsed.err == nil) {
|
||||
retval[k1][k2][k3][k4][k5] = entry.parsed
|
||||
} else {
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return retval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Returns the value of an environment variable.
|
||||
// If the variable is not defined as envconf.TypeInt the function will return 0.
|
||||
func (c *Config) GetInt(key string) int64 {
|
||||
@ -384,6 +533,356 @@ func (c *Config) GetBool(key string) bool {
|
||||
return val.boolval
|
||||
}
|
||||
|
||||
func (c *Config) GetMapInt(key string) (retval map[string]int64) {
|
||||
retval = make(map[string]int64)
|
||||
for k, v := range c.getRawMap(key, TypeInt) {
|
||||
retval[k] = v.intval
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapDuration(key string) (retval map[string]time.Duration) {
|
||||
retval = make(map[string]time.Duration)
|
||||
for k, v := range c.getRawMap(key, TypeDuration) {
|
||||
retval[k] = v.durval
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapString(key string) (retval map[string]string) {
|
||||
retval = make(map[string]string)
|
||||
for k, v := range c.getRawMap(key, TypeString) {
|
||||
retval[k] = v.strval
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapBool(key string) (retval map[string]bool) {
|
||||
retval = make(map[string]bool)
|
||||
for k, v := range c.getRawMap(key, TypeBool) {
|
||||
retval[k] = v.boolval
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapHex(key string) (retval map[string][]byte) {
|
||||
retval = make(map[string][]byte)
|
||||
for k, v := range c.getRawMap(key, TypeHex) {
|
||||
retval[k] = v.binval
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapInt(key string) (retval map[string]map[string]int64) {
|
||||
retval = make(map[string]map[string]int64)
|
||||
for k1, v1 := range c.getRawMapMap(key, TypeInt) {
|
||||
retval[k1] = make(map[string]int64)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = v2.intval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapDuration(key string) (retval map[string]map[string]time.Duration) {
|
||||
retval = make(map[string]map[string]time.Duration)
|
||||
for k1, v1 := range c.getRawMapMap(key, TypeDuration) {
|
||||
retval[k1] = make(map[string]time.Duration)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = v2.durval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapString(key string) (retval map[string]map[string]string) {
|
||||
retval = make(map[string]map[string]string)
|
||||
for k1, v1 := range c.getRawMapMap(key, TypeString) {
|
||||
retval[k1] = make(map[string]string)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = v2.strval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapBool(key string) (retval map[string]map[string]bool) {
|
||||
retval = make(map[string]map[string]bool)
|
||||
for k1, v1 := range c.getRawMapMap(key, TypeBool) {
|
||||
retval[k1] = make(map[string]bool)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = v2.boolval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapHex(key string) (retval map[string]map[string][]byte) {
|
||||
retval = make(map[string]map[string][]byte)
|
||||
for k1, v1 := range c.getRawMapMap(key, TypeHex) {
|
||||
retval[k1] = make(map[string][]byte)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = v2.binval
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapInt(key string) (retval map[string]map[string]map[string]int64) {
|
||||
retval = make(map[string]map[string]map[string]int64)
|
||||
for k1, v1 := range c.getRawMapMapMap(key, TypeInt) {
|
||||
retval[k1] = make(map[string]map[string]int64)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]int64)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = v3.intval
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapDuration(key string) (retval map[string]map[string]map[string]time.Duration) {
|
||||
retval = make(map[string]map[string]map[string]time.Duration)
|
||||
for k1, v1 := range c.getRawMapMapMap(key, TypeDuration) {
|
||||
retval[k1] = make(map[string]map[string]time.Duration)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]time.Duration)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = v3.durval
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapString(key string) (retval map[string]map[string]map[string]string) {
|
||||
retval = make(map[string]map[string]map[string]string)
|
||||
for k1, v1 := range c.getRawMapMapMap(key, TypeString) {
|
||||
retval[k1] = make(map[string]map[string]string)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]string)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = v3.strval
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapBool(key string) (retval map[string]map[string]map[string]bool) {
|
||||
retval = make(map[string]map[string]map[string]bool)
|
||||
for k1, v1 := range c.getRawMapMapMap(key, TypeBool) {
|
||||
retval[k1] = make(map[string]map[string]bool)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]bool)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = v3.boolval
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapHex(key string) (retval map[string]map[string]map[string][]byte) {
|
||||
retval = make(map[string]map[string]map[string][]byte)
|
||||
for k1, v1 := range c.getRawMapMapMap(key, TypeHex) {
|
||||
retval[k1] = make(map[string]map[string][]byte)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string][]byte)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = v3.binval
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapInt(key string) (retval map[string]map[string]map[string]map[string]int64) {
|
||||
retval = make(map[string]map[string]map[string]map[string]int64)
|
||||
for k1, v1 := range c.getRawMapMapMapMap(key, TypeInt) {
|
||||
retval[k1] = make(map[string]map[string]map[string]int64)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]int64)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]int64)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = v4.intval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapDuration(key string) (retval map[string]map[string]map[string]map[string]time.Duration) {
|
||||
retval = make(map[string]map[string]map[string]map[string]time.Duration)
|
||||
for k1, v1 := range c.getRawMapMapMapMap(key, TypeDuration) {
|
||||
retval[k1] = make(map[string]map[string]map[string]time.Duration)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]time.Duration)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]time.Duration)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = v4.durval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapString(key string) (retval map[string]map[string]map[string]map[string]string) {
|
||||
retval = make(map[string]map[string]map[string]map[string]string)
|
||||
for k1, v1 := range c.getRawMapMapMapMap(key, TypeString) {
|
||||
retval[k1] = make(map[string]map[string]map[string]string)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]string)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]string)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = v4.strval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapBool(key string) (retval map[string]map[string]map[string]map[string]bool) {
|
||||
retval = make(map[string]map[string]map[string]map[string]bool)
|
||||
for k1, v1 := range c.getRawMapMapMapMap(key, TypeBool) {
|
||||
retval[k1] = make(map[string]map[string]map[string]bool)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]bool)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]bool)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = v4.boolval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapHex(key string) (retval map[string]map[string]map[string]map[string][]byte) {
|
||||
retval = make(map[string]map[string]map[string]map[string][]byte)
|
||||
for k1, v1 := range c.getRawMapMapMapMap(key, TypeHex) {
|
||||
retval[k1] = make(map[string]map[string]map[string][]byte)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string][]byte)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string][]byte)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = v4.binval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapMapInt(key string) (retval map[string]map[string]map[string]map[string]map[string]int64) {
|
||||
retval = make(map[string]map[string]map[string]map[string]map[string]int64)
|
||||
for k1, v1 := range c.getRawMapMapMapMapMap(key, TypeInt) {
|
||||
retval[k1] = make(map[string]map[string]map[string]map[string]int64)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]map[string]int64)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]map[string]int64)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = make(map[string]int64)
|
||||
for k5, v5 := range v4 {
|
||||
retval[k1][k2][k3][k4][k5] = v5.intval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapMapDuration(key string) (retval map[string]map[string]map[string]map[string]map[string]time.Duration) {
|
||||
retval = make(map[string]map[string]map[string]map[string]map[string]time.Duration)
|
||||
for k1, v1 := range c.getRawMapMapMapMapMap(key, TypeDuration) {
|
||||
retval[k1] = make(map[string]map[string]map[string]map[string]time.Duration)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]map[string]time.Duration)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]map[string]time.Duration)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = make(map[string]time.Duration)
|
||||
for k5, v5 := range v4 {
|
||||
retval[k1][k2][k3][k4][k5] = v5.durval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapMapString(key string) (retval map[string]map[string]map[string]map[string]map[string]string) {
|
||||
retval = make(map[string]map[string]map[string]map[string]map[string]string)
|
||||
for k1, v1 := range c.getRawMapMapMapMapMap(key, TypeString) {
|
||||
retval[k1] = make(map[string]map[string]map[string]map[string]string)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]map[string]string)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]map[string]string)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = make(map[string]string)
|
||||
for k5, v5 := range v4 {
|
||||
retval[k1][k2][k3][k4][k5] = v5.strval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapMapBool(key string) (retval map[string]map[string]map[string]map[string]map[string]bool) {
|
||||
retval = make(map[string]map[string]map[string]map[string]map[string]bool)
|
||||
for k1, v1 := range c.getRawMapMapMapMapMap(key, TypeBool) {
|
||||
retval[k1] = make(map[string]map[string]map[string]map[string]bool)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]map[string]bool)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]map[string]bool)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = make(map[string]bool)
|
||||
for k5, v5 := range v4 {
|
||||
retval[k1][k2][k3][k4][k5] = v5.boolval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *Config) GetMapMapMapMapMapHex(key string) (retval map[string]map[string]map[string]map[string]map[string][]byte) {
|
||||
retval = make(map[string]map[string]map[string]map[string]map[string][]byte)
|
||||
for k1, v1 := range c.getRawMapMapMapMapMap(key, TypeHex) {
|
||||
retval[k1] = make(map[string]map[string]map[string]map[string][]byte)
|
||||
for k2, v2 := range v1 {
|
||||
retval[k1][k2] = make(map[string]map[string]map[string][]byte)
|
||||
for k3, v3 := range v2 {
|
||||
retval[k1][k2][k3] = make(map[string]map[string][]byte)
|
||||
for k4, v4 := range v3 {
|
||||
retval[k1][k2][k3][k4] = make(map[string][]byte)
|
||||
for k5, v5 := range v4 {
|
||||
retval[k1][k2][k3][k4][k5] = v5.binval
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func getFirstRune(str string) rune {
|
||||
for _, v := range str {
|
||||
return v
|
||||
|
||||
155
generate.py
155
generate.py
@ -1,155 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import typing
|
||||
import tempfile
|
||||
import os.path
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
from dataclasses import dataclass
|
||||
|
||||
|
||||
@dataclass
|
||||
class DataType:
|
||||
const_type: str
|
||||
go_type: str
|
||||
sig_type: str
|
||||
value_type: str
|
||||
|
||||
|
||||
def get_return_type(levels: int, dtype: str) -> str:
|
||||
return ("map[string]" * levels) + dtype
|
||||
|
||||
|
||||
def get_signature(levels: int, data_type: DataType) -> str:
|
||||
return (
|
||||
"func (c *Config) Get"
|
||||
+ ("Map" * levels)
|
||||
+ data_type.sig_type
|
||||
+ "(key string) (empty "
|
||||
+ get_return_type(levels, data_type.go_type)
|
||||
+ ") {"
|
||||
)
|
||||
|
||||
|
||||
def get_empty_def(levels: int, data_type: DataType) -> str:
|
||||
return "empty = make(" + get_return_type(levels, data_type.go_type) + ")"
|
||||
|
||||
|
||||
def get_nested_keys(levels: int) -> str:
|
||||
txt = ""
|
||||
for count in range(levels):
|
||||
txt += "[k" + str(count + 11) + "]"
|
||||
return txt
|
||||
|
||||
|
||||
def get_retval_def(levels: int, current_level: int, data_type: DataType) -> str:
|
||||
base = "retval := make("
|
||||
if current_level > 0:
|
||||
base = "retval" + get_nested_keys(current_level) + " = make("
|
||||
return base + get_return_type(levels - current_level, data_type.go_type) + ")"
|
||||
|
||||
|
||||
def get_entries(levels: int) -> str:
|
||||
return f"v10, ok := c.mapEnv[{levels-1}].next[key]"
|
||||
|
||||
|
||||
def get_entry(levels: int) -> str:
|
||||
return f"entry := c.env[v{levels + 11}.key]"
|
||||
|
||||
|
||||
def set_value(levels: int, data_type: DataType) -> str:
|
||||
return f"retval{get_nested_keys(levels + 1)} = entry.parsed.{data_type.value_type}"
|
||||
|
||||
|
||||
def get_loop(levels: int) -> str:
|
||||
return f"for k{levels + 11}, v{levels + 11} := range v{levels + 10}.next {{"
|
||||
|
||||
|
||||
def get_function(file: typing.TextIO, levels: int, data_type: DataType):
|
||||
print(get_signature(levels, data_type), file=file)
|
||||
print(get_empty_def(levels, data_type), file=file)
|
||||
print(get_retval_def(levels, 0, data_type), file=file)
|
||||
print("if c.parsed {", file=file)
|
||||
print("key = cleanKey(key)", file=file)
|
||||
print(get_entries(levels), file=file)
|
||||
print("if ok {", file=file)
|
||||
for level in range(levels - 1):
|
||||
print(get_loop(level), file=file)
|
||||
print(get_retval_def(levels, level + 1, data_type), file=file)
|
||||
print(get_loop(levels - 1), file=file)
|
||||
print(get_entry(levels - 1), file=file)
|
||||
print(
|
||||
f"if (entry.dtype.baseType() == {data_type.const_type}.baseType()) && (entry.parsed.err == nil) {{",
|
||||
file=file,
|
||||
)
|
||||
print(set_value(levels - 1, data_type), file=file)
|
||||
print("} else {", file=file)
|
||||
print("return", file=file)
|
||||
print("};" * (levels + 1), file=file)
|
||||
print("return retval", file=file)
|
||||
print("}", file=file)
|
||||
print("}", file=file)
|
||||
print("return", file=file)
|
||||
print("}", file=file)
|
||||
|
||||
|
||||
def main():
|
||||
data_types = [
|
||||
DataType(
|
||||
const_type="TypeInt", go_type="int64", sig_type="Int", value_type="intval"
|
||||
),
|
||||
DataType(
|
||||
const_type="TypeMetric",
|
||||
go_type="int64",
|
||||
sig_type="Metric",
|
||||
value_type="intval",
|
||||
),
|
||||
DataType(
|
||||
const_type="TypeDuration",
|
||||
go_type="time.Duration",
|
||||
sig_type="Duration",
|
||||
value_type="durval",
|
||||
),
|
||||
DataType(
|
||||
const_type="TypeString",
|
||||
go_type="string",
|
||||
sig_type="String",
|
||||
value_type="strval",
|
||||
),
|
||||
DataType(
|
||||
const_type="TypeDirectory",
|
||||
go_type="string",
|
||||
sig_type="Directory",
|
||||
value_type="strval",
|
||||
),
|
||||
DataType(
|
||||
const_type="TypeBool", go_type="bool", sig_type="Bool", value_type="boolval"
|
||||
),
|
||||
DataType(
|
||||
const_type="TypeHex", go_type="[]byte", sig_type="Hex", value_type="binval"
|
||||
),
|
||||
]
|
||||
|
||||
levels = 5
|
||||
|
||||
with tempfile.TemporaryDirectory() as pathname:
|
||||
code_file = os.path.join(pathname, "code.go")
|
||||
with open(code_file, mode="w", encoding="utf-8") as f:
|
||||
print("package envconf", file=f)
|
||||
print('import "time"', file=f)
|
||||
print(f"type mapEnvType [{levels}]*keyLookupType", file=f)
|
||||
for level in range(levels):
|
||||
for data_type in data_types:
|
||||
get_function(f, level + 1, data_type)
|
||||
if subprocess.run(["go", "fmt", code_file], check=True).returncode == 0:
|
||||
shutil.copyfile(
|
||||
code_file,
|
||||
os.path.join(
|
||||
os.path.dirname(os.path.realpath(__file__)), "auto_generated.go"
|
||||
),
|
||||
follow_symlinks=False,
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -13,19 +13,10 @@ mkdir -p ${GOPATH}/src
|
||||
mkdir -p ${dir}/bin
|
||||
|
||||
cp -r "${dir}/main.go" "${dir}/buildenv/src/main.go"
|
||||
|
||||
cd ${dir}/buildenv
|
||||
|
||||
go mod init src
|
||||
go mod tidy
|
||||
|
||||
package_name=$(ls ${dir}/buildenv/deps/pkg/mod/git.purser.it/roypur | tr -d "\n")
|
||||
package_dir="${dir}/buildenv/deps/pkg/mod/git.purser.it/roypur/${package_name}"
|
||||
|
||||
chmod -R 777 "${dir}/buildenv/deps"
|
||||
rm -R "${package_dir}"
|
||||
mkdir -p "${package_dir}"
|
||||
|
||||
cp $(dirname ${dir})/*.go ${package_dir}
|
||||
|
||||
cd "${dir}"
|
||||
go build -o "${dir}/bin/test"
|
||||
go build -o "${dir}/bin/test" "src/main.go"
|
||||
|
||||
@ -11,6 +11,6 @@ func main() {
|
||||
conf.DefineMap("test_map", envconf.TypeInt)
|
||||
conf.Parse()
|
||||
conf.Status()
|
||||
fmt.Println(conf.GetMapMapMapMapMapInt("test_map"))
|
||||
fmt.Println(conf.GetMapMapMapInt("test_map"))
|
||||
fmt.Println(conf.GetInt("this_is_a_map"))
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user