// ConfigEntries is used to pull all the config entries for the snapshot.
349623
func (s *Snapshot) ConfigEntries() ([]structs.ConfigEntry, error) {
	entries, err := s.tx.Get(configTableName, "id")
	if err != nil {
		return nil, err
	}

	var ret []structs.ConfigEntry
	for wrapped := entries.Next(); wrapped != nil; wrapped = entries.Next() {
		ret = append(ret, wrapped.(structs.ConfigEntry))
	}

	return ret, nil
}
1073628
func (c *GraphClause) Bindings() []string {
	var bs []string
	for k := range c.BindingsMap() {
		bs = append(bs, k)
	}
	return bs
}
1243478
func (v *Value) ConfigItems() []*config.Config {
	if len(v.Items) == 0 {
		return nil
	}

	res := make([]*config.Config, len(v.Items))
	for i := range v.Items {
		res[i] = v.Items[i].ConfigItem()
	}
	return res
}
1131762
func (s *RemoteApplication) Bindings() map[string]string {
	result := make(map[string]string)
	for epName, spName := range s.doc.Bindings {
		result[epName] = spName
	}
	return result
}
1128859
func KnownConfigKeys(schema environschema.Fields) set.Strings {
	result := set.NewStrings()
	for name := range schema {
		result.Add(name)
	}
	return result
}
187991
func (h *healthcheckManager) configs() map[healthcheck.Id]*healthcheck.Config {
	h.lock.RLock()
	defer h.lock.RUnlock()
	if !h.enabled {
		return nil
	}
	return h.cfgs
}
130670
func ConfigDefaults(providerDefaults schema.Defaults) schema.Defaults {
	defaults := schema.Defaults{
		JujuApplicationPath: JujuDefaultApplicationPath,
	}
	for key, value := range providerDefaults {
		if value == schema.Omit {
			continue
		}
		defaults[key] = value
	}
	return defaults
}
853686
func (c *ConfigParser) Sections() (res []string) {
	for k, _ := range c.sections {
		res = append(res, k)
	}
	return res
}
105638
func (c Config) Features() set.Strings {
	features := set.NewStrings()
	if value, ok := c[Features]; ok {
		value := value.([]interface{})
		for _, item := range value {
			features.Add(item.(string))
		}
	}
	return features
}
1286079
func (c *Host) PullBinariesAndConfig(repository, binDir, configDir, version string, tufDB io.Reader) (map[string]string, error) {
	query := make(url.Values)
	query.Set("repository", repository)
	query.Set("bin-dir", binDir)
	query.Set("config-dir", configDir)
	query.Set("version", version)
	path := "/host/pull/binaries?" + query.Encode()
	var paths map[string]string
	return paths, c.c.Post(path, tufDB, &paths)
}
337953
func (s *ConfigurationService) ListConfigurations(p *ListConfigurationsParams) (*ListConfigurationsResponse, error) {
	resp, err := s.cs.newRequest("listConfigurations", p.toURLValues())
	if err != nil {
		return nil, err
	}

	var r ListConfigurationsResponse
	if err := json.Unmarshal(resp, &r); err != nil {
		return nil, err
	}

	return &r, nil
}
378884
func StringMapToConfigEntries(stringMap map[string]string, operation AlterOperation) []ConfigEntry {
	var ceList []ConfigEntry

	for k, v := range stringMap {
		ceList = append(ceList, ConfigEntry{Name: k, Value: v, Operation: operation})
	}

	return ceList
}
955704
func (s *ListConfigurationsResponse) SetConfigurations(v []*Configuration) *ListConfigurationsResponse {
	s.Configurations = v
	return s
}
12928
func fetchConfigs(c context.Context, f policy.ConfigFetcher) (policy.ConfigBundle, error) {
	cfg := &admin.ServiceAccountsPermissions{}
	if err := f.FetchTextProto(c, serviceAccountsCfg, cfg); err != nil {
		return nil, err
	}
	return policy.ConfigBundle{serviceAccountsCfg: cfg}, nil
}
1157212
func ConfigRegs(ctx types.Context) <-chan gofig.ConfigRegistration {
	c := make(chan gofig.ConfigRegistration)
	go func() {
		cfgRegsRWL.RLock()
		defer cfgRegsRWL.RUnlock()
		for _, cr := range cfgRegs {
			r := NewConfigReg(cr.name)
			cr.creg(ctx, r)
			c <- r
		}
		close(c)
	}()
	return c
}
414189
func (s *DescribeConfigurationsOutput) SetConfigurations(v []map[string]*string) *DescribeConfigurationsOutput {
	s.Configurations = v
	return s
}
1064269
func (fc *FeatureCollection) FillProperties() {
	properties := make(map[string]bool)

	// Loop 1: construct a set (actually a map)
	for _, feature := range fc.Features {
		for key := range feature.Properties {
			if _, ok := properties[key]; !ok {
				properties[key] = true
			}
		}
	}

	// Loop 2: make sure each feature has each property from the set
	for _, feature := range fc.Features {
		for key := range properties {
			if _, ok := feature.Properties[key]; !ok {
				feature.Properties[key] = nil
			}
		}
	}
}