// Map is a helper method to unmarshal to a JSON Object.
501803
func (p *Partial) Map() (m map[string]*Partial, err error) {
	err = p.Unmarshal(&m)
	return
}
347386
func (ms *MapperStruct) Map(key, val sophie.SophieWriter,
	c PartCollector) error {

	if ms.MapF != nil {
		return ms.MapF(key, val, c)
	}

	return nil
}
1004773
func (mp MultiPoint) Map() map[string]interface{} {
	result := make(map[string]interface{})
	result[COORDINATES] = mp.Coordinates
	result[TYPE] = MULTIPOINT
	return result
}
736934
func (point Point) Map() map[string]interface{} {
	result := make(map[string]interface{})
	result[COORDINATES] = point.Coordinates
	result[TYPE] = POINT
	return result
}
740784
func (p *pathObject) Map(call goja.FunctionCall) goja.Value {
	return p.ForEach(call)
}
781390
func (w *WatchPodMapper) Map(obj handler.MapObject) []reconcile.Request {
	pod, ok := obj.Object.(*corev1.Pod)
	if !ok {
		return nil
	}

	if pod.Spec.NodeName != w.nodeName {
		return nil
	}

	if pod.Spec.HostNetwork && !w.enableHostPods {
		return nil
	}

	return []reconcile.Request{
		{
			NamespacedName: types.NamespacedName{
				Name:      pod.Name,
				Namespace: pod.Namespace,
			},
		},
	}
}
60772
func YAML(in string) (map[string]interface{}, error) {
	obj := make(map[string]interface{})
	return unmarshalObj(obj, in, yaml.Unmarshal)
}
917127
func (lu *LookupUnique) Map(vcursor VCursor, ids []sqltypes.Value) ([]key.Destination, error) {
	out := make([]key.Destination, 0, len(ids))
	if lu.writeOnly {
		for range ids {
			out = append(out, key.DestinationKeyRange{KeyRange: &topodatapb.KeyRange{}})
		}
		return out, nil
	}
	results, err := lu.lkp.Lookup(vcursor, ids)
	if err != nil {
		return nil, err
	}
	for i, result := range results {
		switch len(result.Rows) {
		case 0:
			out = append(out, key.DestinationNone{})
		case 1:
			out = append(out, key.DestinationKeyspaceID(result.Rows[0][0].ToBytes()))
		default:
			return nil, fmt.Errorf("Lookup.Map: unexpected multiple results from vindex %s: %v", lu.lkp.Table, ids[i])
		}
	}
	return out, nil
}
9266
func UnmarshalMap(m map[string]*dynamodb.AttributeValue, out interface{}) error {
	return NewDecoder().Decode(&dynamodb.AttributeValue{M: m}, out)
}
781550
func (args Args) Map() map[string]interface{} {
	m := make(map[string]interface{})
	for _, arg := range args {
		m[arg.Name] = arg.Value
	}
	return m
}
19603
func Map(f func(float64) float64, xs []float64) []float64 {
	// TODO(austin) Parallelize
	res := make([]float64, len(xs))
	for i, x := range xs {
		res[i] = f(x)
	}
	return res
}
419161
func (mls MultiLineString) Map() map[string]interface{} {
	result := make(map[string]interface{})
	result[COORDINATES] = mls.Coordinates
	result[TYPE] = MULTILINESTRING
	return result
}
207832
func (polygon Polygon) Map() map[string]interface{} {
	result := make(map[string]interface{})
	result[COORDINATES] = polygon.Coordinates
	result[TYPE] = POLYGON
	return result
}
406692
func (m *mapping) Map(c Compo) (f func(), err error) {
	if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
		return nil, err
	}

	return m.mapTo(reflect.ValueOf(c))
}
1205657
func FlattenJsonMap(m map[string]interface{}) (map[string][]string, error) {
	outMap := make(map[string][]string, len(m))
	if err := flattenJson("", outMap, m); err != nil {
		return nil, err
	}
	return outMap, nil
}
1135272
func (w *Window) Map() {
	if w == nil {
		return
	}

	xproto.MapWindow(w.X.Conn(), w.Id)
}
1185323
func (e Env) Map() map[string]string {
	if len(e.env) == 0 {
		return nil
	}

	m := make(map[string]string, len(e.env))
	for k, entry := range e.env {
		ek, ev := splitEntryGivenKey(k, entry)
		m[ek] = ev
	}
	return m
}