// projectToSelectableFields returns a field set that represents the object
770465
func projectToSelectableFields(projectObj *projectapi.Project) fields.Set {
	objectMetaFieldsSet := generic.ObjectMetaFieldsSet(&projectObj.ObjectMeta, false)
	specificFieldsSet := fields.Set{
		"status.phase": string(projectObj.Status.Phase),
	}
	return generic.MergeFieldsSets(objectMetaFieldsSet, specificFieldsSet)
}
1240025
func (p *MercatorProjection) Project(pt Point) r2.Point {
	return p.FromLatLng(LatLngFromPoint(pt))
}
1100921
func NewSimpleFields(p level.Priority, f Fields) Composer {
	m := MakeSimpleFields(f)
	_ = m.SetPriority(p)
	return m
}
1114307
func (p *PlateCarreeProjection) Project(pt Point) r2.Point {
	return p.FromLatLng(LatLngFromPoint(pt))
}
1352173
func DropDisabledFields(pspSpec, oldPSPSpec *policy.PodSecurityPolicySpec) {
	if !utilfeature.DefaultFeatureGate.Enabled(features.ProcMountType) && !allowedProcMountTypesInUse(oldPSPSpec) {
		pspSpec.AllowedProcMountTypes = nil
	}
	if !utilfeature.DefaultFeatureGate.Enabled(features.RunAsGroup) && (oldPSPSpec == nil || oldPSPSpec.RunAsGroup == nil) {
		pspSpec.RunAsGroup = nil
	}
	if !utilfeature.DefaultFeatureGate.Enabled(features.Sysctls) && !sysctlsInUse(oldPSPSpec) {
		pspSpec.AllowedUnsafeSysctls = nil
		pspSpec.ForbiddenSysctls = nil
	}
	if !utilfeature.DefaultFeatureGate.Enabled(features.CSIInlineVolume) {
		pspSpec.AllowedCSIDrivers = nil
	}
	if !utilfeature.DefaultFeatureGate.Enabled(features.RuntimeClass) &&
		(oldPSPSpec == nil || oldPSPSpec.RuntimeClass == nil) {
		pspSpec.RuntimeClass = nil
	}
}
756749
func (c *Client) ListProjects(p *ListProjectsParameter) ([]*Project, error) {
	obj, err := c.Request("listProjects", convertParamToMap(p))
	if err != nil {
		return nil, err
	}
	return obj.([]*Project), err
}
694514
func ActiveProjects(c context.Context) ([]types.ProjectName, error) {
	return ProjectNames(c, cfgclient.AsService)
}
695718
func (s *IntArrayOptions) SetSourceFields(v string) *IntArrayOptions {
	s.SourceFields = &v
	return s
}
311031
func (e *engineImpl) GetVisibleProjectJobs(c context.Context, projectID string) ([]*Job, error) {
	q := ds.NewQuery("Job").Eq("Enabled", true).Eq("ProjectID", projectID)
	return e.queryEnabledVisibleJobs(c, q)
}
127194
func Convert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector(in *v1.ObjectFieldSelector, out *core.ObjectFieldSelector, s conversion.Scope) error {
	return autoConvert_v1_ObjectFieldSelector_To_core_ObjectFieldSelector(in, out, s)
}
259865
func (o *OpenTrackingSetting) SetEnable(enable bool) *OpenTrackingSetting {
	setEnable := enable
	o.Enable = &setEnable
	return o
}
234001
func DropDisabledTemplateFields(podTemplate, oldPodTemplate *api.PodTemplateSpec) {
	var (
		podSpec           *api.PodSpec
		podAnnotations    map[string]string
		oldPodSpec        *api.PodSpec
		oldPodAnnotations map[string]string
	)
	if podTemplate != nil {
		podSpec = &podTemplate.Spec
		podAnnotations = podTemplate.Annotations
	}
	if oldPodTemplate != nil {
		oldPodSpec = &oldPodTemplate.Spec
		oldPodAnnotations = oldPodTemplate.Annotations
	}
	dropDisabledFields(podSpec, podAnnotations, oldPodSpec, oldPodAnnotations)
}
1281433
func setEmptyFieldsFromActual(requested, actual interface{}, fields ...string) error {
	requestedValue := reflect.ValueOf(requested).Elem()
	actualValue := reflect.ValueOf(actual).Elem()

	if requestedValue.Type() != actualValue.Type() {
		return errors.Errorf("attempted to set fields from different types: %q from %q",
			requestedValue, actualValue)
	}

	for _, field := range fields {
		requestedField := requestedValue.FieldByName(field)
		if !requestedField.IsValid() {
			return errors.Errorf("no such field %q to cleanup", field)
		}
		actualField := actualValue.FieldByName(field)
		if !actualField.IsValid() {
			return errors.Errorf("no such field %q to cleanup", field)
		}

		if reflect.DeepEqual(requestedField.Interface(), reflect.Zero(requestedField.Type()).Interface()) {
			requestedField.Set(actualField)
		}
	}

	return nil
}
1029542
func SetToFields(s fieldpath.Set) (metav1.Fields, error) {
	var err error
	f := newFields()
	s.Iterate(func(path fieldpath.Path) {
		if err != nil {
			return
		}
		tf := f
		for _, pe := range path {
			var str string
			str, err = PathElementString(pe)
			if err != nil {
				break
			}
			if _, ok := tf.Map[str]; ok {
				tf = tf.Map[str]
			} else {
				tf.Map[str] = newFields()
				tf = tf.Map[str]
			}
		}
		tf.Map["."] = newFields()
	})
	f = removeUselessDots(f)
	return f, err
}
427902
func (g *Geometry) ProjectNormalized(p *Geometry) float64 {
	// XXX: error if wrong geometry types
	return float64(cGEOSProjectNormalized(g.g, p.g))
}
531935
func FieldsToSet(f metav1.Fields) (fieldpath.Set, error) {
	set := fieldpath.Set{}
	return set, fieldsSet(f, fieldpath.Path{}, &set)
}
1256458
func ReplicaSetToSelectableFields(rs *apps.ReplicaSet) fields.Set {
	objectMetaFieldsSet := generic.ObjectMetaFieldsSet(&rs.ObjectMeta, true)
	rsSpecificFieldsSet := fields.Set{
		"status.replicas": strconv.Itoa(int(rs.Status.Replicas)),
	}
	return generic.MergeFieldsSets(objectMetaFieldsSet, rsSpecificFieldsSet)
}