// OnlyMapper interface
966946
func (oms *OnlyMapperStruct) NewVal() sophie.Sophier {
	if oms.NewValF != nil {
		return oms.NewValF()
	}
	return new(sophie.RawByteSlice)
}
82246
func (g *Container) ChildrenMap() (map[string]*Container, error) {
	if mmap, ok := g.Data().(map[string]interface{}); ok {
		children := map[string]*Container{}
		for name, obj := range mmap {
			children[name] = &Container{obj}
		}
		return children, nil
	}
	return nil, ErrNotObj
}
1063167
func (ss *simpleSource) OutputMap() map[string]interface{} {
	var jsonMap map[string]interface{}
	if err := json.Unmarshal(ss.rawData, &jsonMap); err != nil {
		fmt.Println(err)
		return nil
	}
	return jsonMap
}
1016348
func (c *CloudPersister) ListMaps() ([]*models.Map, error) {
	ctx := context.Background()
	Maps := make([]*models.Map, 0)
	q := datastore.NewQuery("Map")

	keys, err := c.DatastoreClient().GetAll(ctx, q, &Maps)

	if err != nil {
		return nil, fmt.Errorf("datastoredb: could not list Maps: %v", err)
	}

	for i, k := range keys {
		Maps[i].ID = k.ID()
	}

	return Maps, nil
}
468923
func AsMap(resources []Resource) map[string]Resource {
	results := make(map[string]Resource, len(resources))
	for _, res := range resources {
		results[res.Name] = res
	}
	return results
}
123412
func (s *Service) GetMapping() *GetMappingCall {
	c := &GetMappingCall{s: s, urlParams_: make(gensupport.URLParams)}
	return c
}
739745
func (d Data) AsMap() map[string]interface{} {
	m := make(map[string]interface{})
	for key := range d {
		m[key] = d[key]
	}
	return m
}
1149739
func (o *Me) CreatePATMapper(child *PATMapper) *bambou.Error {

	return bambou.CurrentSession().CreateChild(o, child)
}
560708
func MapToResource(resourceMap interface{}, asPointer bool) interface{} {
	b, _ := json.Marshal(&resourceMap)
	m := resourceMap.(map[string]interface{})
	t := m["resourceType"]

	if t == nil {
		return nil
	}

	var x interface{} = StructForResourceName(t.(string))

	if x == nil {
		return nil
	}

	json.Unmarshal(b, &x)

	if asPointer {
		return &x
	}
	return x
}
742778
func IsMap(err error) bool {
	if err != nil {
		switch err.(type) {
		case *Map:
			return true
		}
	}
	return false
}
821098
func (f *Factory) NilClientMapperForCommand() resource.ClientMapper {
	return resource.ClientMapperFunc(func(mapping *meta.RESTMapping) (resource.RESTClient, error) {
		return nil, nil
	})
}
411799
func (v Values) AsMap() map[string]interface{} {
	if v == nil || len(v) == 0 {
		return map[string]interface{}{}
	}
	return v
}
501803
func (p *Partial) Map() (m map[string]*Partial, err error) {
	err = p.Unmarshal(&m)
	return
}
307148
func (m FirstHitRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*RESTMapping, error) {
	errors := []error{}
	for _, t := range m.MultiRESTMapper {
		ret, err := t.RESTMapping(gk, versions...)
		if err == nil {
			return ret, nil
		}
		errors = append(errors, err)
	}

	return nil, collapseAggregateErrors(errors)
}
997797
func (c *CloudPersister) GetMap(id int64) (*models.Map, error) {
	ctx := context.Background()
	k := datastore.NewKey(ctx, "Map", "", id, nil)
	Map := &models.Map{}
	if err := c.DatastoreClient().Get(ctx, k, Map); err != nil {
		return nil, fmt.Errorf("datastoredb: could not get Map: %v", err)
	}
	Map.ID = id
	return Map, nil
}
781921
func RegisterMapper(fn Mapper) MapperId {
	mappersLock.Lock()
	defer mappersLock.Unlock()

	mapperId := MapperId(fmt.Sprintf("m%d", len(mappers)+1))
	mappers[mapperId] = MapperObject{fn, runtime.FuncForPC(reflect.ValueOf(fn).Pointer()).Name()}

	return mapperId
}
813340
func (e shortcutExpander) RESTMapping(gk schema.GroupKind, versions ...string) (*meta.RESTMapping, error) {
	return e.RESTMapper.RESTMapping(gk, versions...)
}