// GetMany provides a mock function with given fields: uids, options
175467
func (_m *Client) GetMany(uids []string, options groveclient.GetManyOptions) (*groveclient.GetManyOutput, error) {
	ret := _m.Called(uids, options)

	var r0 *groveclient.GetManyOutput
	if rf, ok := ret.Get(0).(func([]string, groveclient.GetManyOptions) *groveclient.GetManyOutput); ok {
		r0 = rf(uids, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*groveclient.GetManyOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func([]string, groveclient.GetManyOptions) error); ok {
		r1 = rf(uids, options)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
159213
func (e *Store) Get(ctx context.Context, name string, options *metav1.GetOptions) (runtime.Object, error) {
	obj := e.NewFunc()
	key, err := e.KeyFunc(ctx, name)
	if err != nil {
		return nil, err
	}
	if err := e.Storage.Get(ctx, key, options.ResourceVersion, obj, false); err != nil {
		return nil, storeerr.InterpretGetError(err, e.qualifiedResourceFromContext(ctx), name)
	}
	if e.Decorator != nil {
		if err := e.Decorator(obj); err != nil {
			return nil, err
		}
	}
	return obj, nil
}
455516
func (ns *NamedStopwatch) AddMany(names []string) error {
	ns.Lock()
	defer ns.Unlock()

	for _, name := range names {
		if err := ns.add(name); err != nil {
			return err
		}
	}
	return nil
}
246674
func mapMany(scaler Scaler, seq table.Slice) table.Slice {
	sv := reflect.ValueOf(seq)
	rt := reflect.SliceOf(scaler.RangeType())
	if seq == nil {
		return reflect.MakeSlice(rt, 0, 0).Interface()
	}
	res := reflect.MakeSlice(rt, sv.Len(), sv.Len())
	for i, len := 0, sv.Len(); i < len; i++ {
		val := scaler.Map(sv.Index(i).Interface())
		res.Index(i).Set(reflect.ValueOf(val))
	}
	return res.Interface()
}
406018
func (lazy *lazyProto) GetValue(out proto.Message) error {
	if lazy.val != nil {
		proto.Merge(out, lazy.val)
	}
	return nil
}
760327
func (r *movieMemoryRepository) SelectMany(query Query, limit int) (results []datamodels.Movie) {
	r.Exec(query, func(m datamodels.Movie) bool {
		results = append(results, m)
		return true
	}, limit, ReadOnlyMode)

	return
}
1245277
func (s *Semaphore) AcquireMany(n int) {
	if n > s.permits {
		n = s.permits
	}

	for ; n > 0; n-- {
		s.Acquire()
	}
}
357249
func (pool *hostConnPool) connectMany(count int) error {
	if count == 0 {
		return nil
	}
	var (
		wg         sync.WaitGroup
		mu         sync.Mutex
		connectErr error
	)
	wg.Add(count)
	for i := 0; i < count; i++ {
		go func() {
			defer wg.Done()
			err := pool.connect()
			pool.logConnectErr(err)
			if err != nil {
				mu.Lock()
				connectErr = err
				mu.Unlock()
			}
		}()
	}
	// wait for all connections are done
	wg.Wait()

	return connectErr
}
952862
func (networkOfferingApi *NetworkOfferingApi) Get(id string) (*NetworkOffering, error) {
	data, err := networkOfferingApi.entityService.Get(id, map[string]string{})
	if err != nil {
		return nil, err
	}
	return parseNetworkOffering(data), nil
}
79678
func (s *Set) GetValue(name interface{}) string {
	if opt := s.Lookup(name); opt != nil {
		return opt.String()
	}
	return ""
}
920273
func (q Query) SelectManyBy(selector func(interface{}) Query,
	resultSelector func(interface{}, interface{}) interface{}) Query {

	return Query{
		Iterate: func() Iterator {
			outernext := q.Iterate()
			var outer interface{}
			var innernext Iterator

			return func() (item interface{}, ok bool) {
				for !ok {
					if outer == nil {
						outer, ok = outernext()
						if !ok {
							return
						}

						innernext = selector(outer).Iterate()
					}

					item, ok = innernext()
					if !ok {
						outer = nil
					}
				}

				item = resultSelector(item, outer)
				return
			}
		},
	}
}
192643
func (list *List) GetValue() interface{} {
	var values []interface{}
	for _, val := range list.values {
		values = append(values, val.GetValue())
	}
	return values
}
558926
func (v *Object) GetValue(keys ...string) (*Value, error) {
	return v.getPath(keys)
}
1008472
func (ir *generatorRegistry) get(key GeneratorID) InterfaceGeneratorFunc {
	g, _ := ir.generators[key]
	return g
}
1297981
func (c *MovieController) GetBy(id int64) (movie datamodels.Movie, found bool) {
	return c.Service.GetByID(id) // it will throw 404 if not found.
}
902233
func GetChain(id string) *Chain {
	for _, c := range chains {
		if c.Name == id {
			return &c
		}
	}

	return nil
}
286489
func (r *REST) Get(ctx context.Context, id string, options *metav1.GetOptions) (runtime.Object, error) {
	name, tag, err := nameAndTag(id)
	if err != nil {
		return nil, err
	}

	imageStream, err := r.imageStreamRegistry.GetImageStream(ctx, name, options)
	if err != nil {
		return nil, err
	}

	image, err := r.imageFor(ctx, tag, imageStream)
	if err != nil {
		return nil, err
	}

	return newISTag(tag, imageStream, image, false)
}