// Get takes name of the securityContextConstraints, and returns the corresponding securityContextConstraints object, and an error if there is any.
497063
func (c *FakeSecurityContextConstraints) Get(name string, options v1.GetOptions) (result *security.SecurityContextConstraints, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewRootGetAction(securitycontextconstraintsResource, name), &security.SecurityContextConstraints{})
	if obj == nil {
		return nil, err
	}
	return obj.(*security.SecurityContextConstraints), err
}
1104355
func (context Context) Get(name string) (interface{}, bool) {
	if value, ok := context.Options[name]; ok {
		return value, true
	}

	return nil, false
}
93213
func (e *extractorImpl) GetConstraints(applications ...string) ([]constraints.Value, error) {
	return e.application.GetConstraints(applications...)
}
89115
func (c *Config) Get(key string) (v interface{}) {
	return c.GetKey(c.NewKey(key))
}
641561
func (context *BaseContext) Get(key string) interface{} {
	if value, ok := context.userData[key]; ok {
		return value
	}
	return nil
}
507311
func Get(r *http.Request) *Context {

	// get the context bound to the http.Request
	if v, ok := r.Body.(*wrapper); ok {
		return v.context
	}

	// create a new context
	c := Context{ }
	c.Params = make(Params)
	c.Values = make(Values)
	c.req = r

	// wrap the request and bind the context
	wrapper := wrap(r)
	wrapper.context = &c
	return &c
}
317103
func Get(ctx context.Context) string {
	httpVersion := make([]VersionInfo, 0, 4)
	httpVersion = append(httpVersion, VersionInfo{Name: "cri-o", Version: version.Version})
	httpVersion = append(httpVersion, VersionInfo{Name: "go", Version: runtime.Version()})
	httpVersion = append(httpVersion, VersionInfo{Name: "os", Version: runtime.GOOS})
	httpVersion = append(httpVersion, VersionInfo{Name: "arch", Version: runtime.GOARCH})

	return AppendVersions("", httpVersion...)
}
768479
func Get(req *http.Request, key interface{}) interface{} {
	crc := getContextReadCloser(req)
	return crc.Context()[key]
}
697069
func (m *MockContext) Get(arg0 string, arg1 interface{}) error {
	ret := m.ctrl.Call(m, "Get", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
322301
func (c *ServiceConfigs) Get(name string) (*ServiceConfig, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()
	service, ok := c.m[name]
	return service, ok
}
666641
func (m *SecureMap) Get(key interface{}) interface{} {
	m.lock.RLock()
	k := m.data[key]
	m.lock.RUnlock()
	return k
}
695519
func (c Client) Get(id string, params *stripe.ThreeDSecureParams) (*stripe.ThreeDSecure, error) {
	path := stripe.FormatURLPath("/v1/3d_secure/%s", id)
	tds := &stripe.ThreeDSecure{}
	err := c.B.Call(http.MethodGet, path, c.Key, params, tds)

	return tds, err
}
630057
func GetContext(err error, key string) interface{} {
	if e, ok := err.(withContext); ok {
		return e.Get(key)
	}
	return ""
}
976259
func (c *Context) Get(key string) interface{} {
	if v, ok := c.data[key]; ok {
		return v
	}
	if c.outer != nil {
		return c.outer.Get(key)
	}
	return nil
}
341187
func (c *FakeValidatingWebhookConfigurations) Get(name string, options v1.GetOptions) (result *v1beta1.ValidatingWebhookConfiguration, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewRootGetAction(validatingwebhookconfigurationsResource, name), &v1beta1.ValidatingWebhookConfiguration{})
	if obj == nil {
		return nil, err
	}
	return obj.(*v1beta1.ValidatingWebhookConfiguration), err
}
1003376
func (c *ConfigEntry) Get(args *structs.ConfigEntryQuery, reply *structs.ConfigEntryResponse) error {
	if done, err := c.srv.forward("ConfigEntry.Get", args, args, reply); done {
		return err
	}
	defer metrics.MeasureSince([]string{"config_entry", "get"}, time.Now())

	// Fetch the ACL token, if any.
	rule, err := c.srv.ResolveToken(args.Token)
	if err != nil {
		return err
	}

	// Create a dummy config entry to check the ACL permissions.
	lookupEntry, err := structs.MakeConfigEntry(args.Kind, args.Name)
	if err != nil {
		return err
	}
	if rule != nil && !lookupEntry.CanRead(rule) {
		return acl.ErrPermissionDenied
	}

	return c.srv.blockingQuery(
		&args.QueryOptions,
		&reply.QueryMeta,
		func(ws memdb.WatchSet, state *state.Store) error {
			index, entry, err := state.ConfigEntry(ws, args.Kind, args.Name)
			if err != nil {
				return err
			}

			reply.Index = index
			if entry == nil {
				return nil
			}

			reply.Entry = entry
			return nil
		})
}
617193
func (s *podSecurityPolicyLister) Get(name string) (*v1beta1.PodSecurityPolicy, error) {
	obj, exists, err := s.indexer.GetByKey(name)
	if err != nil {
		return nil, err
	}
	if !exists {
		return nil, errors.NewNotFound(v1beta1.Resource("podsecuritypolicy"), name)
	}
	return obj.(*v1beta1.PodSecurityPolicy), nil
}