// Get populates the passed object by looking up based on objectID.
514439
func (c *Client) Get(objectID string, object Object) error {
	className, err := objectTypeName(object)
	if err != nil {
		return err
	}
	return c.GetClass(className, objectID, object)
}
761687
func (p *Pointer) Get(document interface{}) (interface{}, reflect.Kind, error) {
	return p.get(document, swag.DefaultJSONNameProvider)
}
476913
func (r Result) Get() (runtime.Object, error) {
	if r.err != nil {
		return nil, r.err
	}
	return r.codec.Decode(r.body)
}
1125435
func (i *Info) Get() error {
	obj, err := NewHelper(i.Client, i.Mapping).Get(i.Namespace, i.Name)
	if err != nil {
		return err
	}
	i.Object = obj
	i.ResourceVersion, _ = i.Mapping.MetadataAccessor.ResourceVersion(obj)
	return nil
}
392648
func (ldb *LevelDb) Get(key []byte, ro *opt.ReadOptions) (
	value []byte, err error) {
	defer func() {
		if err != nil {
			err = errors.WithStack(err)
		}
	}()
	return ldb.DB.Get(key, ro)
}
919555
func (aa *AtomicArray) Get(idx int) interface{} {
	// do not lock if not needed
	if idx < 0 || idx >= aa.length {
		return nil
	}

	aa.mutex.RLock()
	res := aa.items[idx]
	aa.mutex.RUnlock()
	return res
}
34053
func (s *selfSubjectRulesReviewLister) Get(name string) (*v1.SelfSubjectRulesReview, error) {
	obj, exists, err := s.indexer.GetByKey(name)
	if err != nil {
		return nil, err
	}
	if !exists {
		return nil, errors.NewNotFound(v1.Resource("selfsubjectrulesreview"), name)
	}
	return obj.(*v1.SelfSubjectRulesReview), nil
}
36865
func (um *UserMap) Get(id string) (User, error) {
	um.Lock()
	defer um.Unlock()

	user, ok := um.Map[id]
	if !ok {
		return User{}, fmt.Errorf("could not find user with id %s", id)
	}
	return user, nil
}
561313
func Get(c *context.APIContext) {
	c.JSON(200, convert.ToOrganization(c.Org.Organization))
}
410436
func (m *MongoCache) Get(key string) (interface{}, error) {
	data, err := m.get(key)
	if err == mgo.ErrNotFound {
		return nil, ErrNotFound
	}

	if err != nil {
		return nil, err
	}

	return data.Value, nil
}
677306
func (a A) Get(vals ...interface{}) (val interface{}) {
	val = get(a(nil).arg(), vals)
	return
}
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
}
98700
func (c *cache) Get(obj interface{}) (item interface{}, exists bool, err error) {
	key, err := c.keyFunc(obj)
	if err != nil {
		return nil, false, KeyError{obj, err}
	}
	return c.GetByKey(key)
}
417084
func (f *DeltaFIFO) Get(obj interface{}) (item interface{}, exists bool, err error) {
	key, err := f.KeyOf(obj)
	if err != nil {
		return nil, false, KeyError{obj, err}
	}
	return f.GetByKey(key)
}
220457
func (m *MemDB) Get(key []byte, o *db.ReadOptions) (value []byte, err error) {
	m.mutex.RLock()
	defer m.mutex.RUnlock()
	n, exactMatch := m.findNode(key, nil)
	vOff := m.nodeData[n+fVal]
	if !exactMatch || vOff == kvOffsetDeletedNode {
		return nil, db.ErrNotFound
	}
	return m.load(vOff), nil
}
1199262
func (i *Index) GetObject(objectID string, object interface{}, opts ...interface{}) error {
	if objectID == "" {
		return errs.ErrMissingObjectID
	}

	opts = opt.InsertExtraURLParam(
		opts,
		"attributesToRetrieve",
		strings.Join(iopt.ExtractAttributesToRetrieve(opts...).Get(), ","),
	)

	path := i.path("/" + url.QueryEscape(objectID))
	return i.transport.Request(&object, http.MethodGet, path, nil, call.Read, opts...)
}
1112175
func (c *Collection) Get(key string, opts *GetOptions) (docOut *GetResult, errOut error) {
	if opts == nil {
		opts = &GetOptions{}
	}

	span := c.startKvOpTrace(opts.ParentSpanContext, "Get")
	defer span.Finish()

	ctx, cancel := c.context(opts.Context, opts.Timeout)
	if cancel != nil {
		defer cancel()
	}

	if (opts.Project == nil || (opts.Project != nil && len(opts.Project.Fields) > 16)) && !opts.WithExpiry {
		// Standard fulldoc
		doc, err := c.get(ctx, span.Context(), key, opts)
		if err != nil {
			return nil, err
		}
		return doc, nil
	}

	lookupOpts := LookupInOptions{Context: ctx, WithExpiry: opts.WithExpiry}
	spec := LookupInSpec{}
	var ops []LookupInOp
	if opts.Project == nil || (len(opts.Project.Fields) > 15 && opts.WithExpiry) {
		// This is a subdoc full doc as WithExpiry is set and projections are either missing or too many.
		ops = append(ops, spec.GetFull(nil))
		opts.Project = &ProjectOptions{}
	} else {
		for _, path := range opts.Project.Fields {
			ops = append(ops, spec.Get(path, nil))
		}
	}

	result, err := c.lookupIn(ctx, span.Context(), key, ops, lookupOpts)
	if err != nil {
		return nil, err
	}

	doc := &GetResult{}
	doc.withExpiration = result.withExpiration
	doc.expiration = result.expiration
	doc.cas = result.cas
	err = doc.fromSubDoc(ops, result, opts.Project.IgnorePathMissingError)
	if err != nil {
		return nil, err
	}

	return doc, nil
}