github.com/safing/portbase@v0.19.5/config/get-safe.go (about)

     1  package config
     2  
     3  import "sync"
     4  
     5  type safe struct{}
     6  
     7  // Concurrent makes concurrency safe get methods available.
     8  var Concurrent = &safe{}
     9  
    10  // GetAsString returns a function that returns the wanted string with high performance.
    11  func (cs *safe) GetAsString(name string, fallback string) StringOption {
    12  	valid := getValidityFlag()
    13  	option, valueCache := getValueCache(name, nil, OptTypeString)
    14  	value := fallback
    15  	if valueCache != nil {
    16  		value = valueCache.stringVal
    17  	}
    18  	var lock sync.Mutex
    19  
    20  	return func() string {
    21  		lock.Lock()
    22  		defer lock.Unlock()
    23  		if !valid.IsSet() {
    24  			valid = getValidityFlag()
    25  			option, valueCache = getValueCache(name, option, OptTypeString)
    26  			if valueCache != nil {
    27  				value = valueCache.stringVal
    28  			} else {
    29  				value = fallback
    30  			}
    31  		}
    32  		return value
    33  	}
    34  }
    35  
    36  // GetAsStringArray returns a function that returns the wanted string with high performance.
    37  func (cs *safe) GetAsStringArray(name string, fallback []string) StringArrayOption {
    38  	valid := getValidityFlag()
    39  	option, valueCache := getValueCache(name, nil, OptTypeStringArray)
    40  	value := fallback
    41  	if valueCache != nil {
    42  		value = valueCache.stringArrayVal
    43  	}
    44  	var lock sync.Mutex
    45  
    46  	return func() []string {
    47  		lock.Lock()
    48  		defer lock.Unlock()
    49  		if !valid.IsSet() {
    50  			valid = getValidityFlag()
    51  			option, valueCache = getValueCache(name, option, OptTypeStringArray)
    52  			if valueCache != nil {
    53  				value = valueCache.stringArrayVal
    54  			} else {
    55  				value = fallback
    56  			}
    57  		}
    58  		return value
    59  	}
    60  }
    61  
    62  // GetAsInt returns a function that returns the wanted int with high performance.
    63  func (cs *safe) GetAsInt(name string, fallback int64) IntOption {
    64  	valid := getValidityFlag()
    65  	option, valueCache := getValueCache(name, nil, OptTypeInt)
    66  	value := fallback
    67  	if valueCache != nil {
    68  		value = valueCache.intVal
    69  	}
    70  	var lock sync.Mutex
    71  
    72  	return func() int64 {
    73  		lock.Lock()
    74  		defer lock.Unlock()
    75  		if !valid.IsSet() {
    76  			valid = getValidityFlag()
    77  			option, valueCache = getValueCache(name, option, OptTypeInt)
    78  			if valueCache != nil {
    79  				value = valueCache.intVal
    80  			} else {
    81  				value = fallback
    82  			}
    83  		}
    84  		return value
    85  	}
    86  }
    87  
    88  // GetAsBool returns a function that returns the wanted int with high performance.
    89  func (cs *safe) GetAsBool(name string, fallback bool) BoolOption {
    90  	valid := getValidityFlag()
    91  	option, valueCache := getValueCache(name, nil, OptTypeBool)
    92  	value := fallback
    93  	if valueCache != nil {
    94  		value = valueCache.boolVal
    95  	}
    96  	var lock sync.Mutex
    97  
    98  	return func() bool {
    99  		lock.Lock()
   100  		defer lock.Unlock()
   101  		if !valid.IsSet() {
   102  			valid = getValidityFlag()
   103  			option, valueCache = getValueCache(name, option, OptTypeBool)
   104  			if valueCache != nil {
   105  				value = valueCache.boolVal
   106  			} else {
   107  				value = fallback
   108  			}
   109  		}
   110  		return value
   111  	}
   112  }