// Owner is a free data retrieval call binding the contract method 0x02571be3.
//
// Solidity: function owner(bytes32 node) constant returns(address)
337884
func (_ENSRegistry *ENSRegistrySession) Owner(node [32]byte) (common.Address, error) {
	return _ENSRegistry.Contract.Owner(&_ENSRegistry.CallOpts, node)
}
393732
func (s *DeleteMarkerEntry) SetOwner(v *Owner) *DeleteMarkerEntry {
	s.Owner = v
	return s
}
924740
func (cg *Consumergroup) PartitionOwner(topic string, partition int32) (*ConsumergroupInstance, error) {
	node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cg.kz.conf.Chroot, cg.Name, topic, partition)
	val, _, err := cg.kz.conn.Get(node)

	// If the node does not exists, nobody has claimed it.
	switch err {
	case nil:
		return &ConsumergroupInstance{cg: cg, ID: string(val)}, nil
	case zk.ErrNoNode:
		return nil, nil
	default:
		return nil, err
	}
}
135780
func GetLockOwner(ctx context.Context) string {
	if owner := ctx.Value(LockOwner); owner != nil {
		if owner, ok := owner.(string); ok {
			return owner
		}
	}
	return ""
}
1245460
func (s *Source) SetOwner(v string) *Source {
	s.Owner = &v
	return s
}
379434
func (a *Account) TransferOwnership(gatewayID, username string) error {
	return a.EditGateway(gatewayID, GatewayEdits{
		Owner: username,
	})
}
1046194
func (s *MultipartUpload) SetOwner(v *Owner) *MultipartUpload {
	s.Owner = v
	return s
}
552553
func (v *VolumeSpec) GetCloneCreatorOwnership(ctx context.Context) (*Ownership, bool) {
	o := v.GetOwnership()

	// If there is user information, then auth is enabled
	if userinfo, ok := auth.NewUserInfoFromContext(ctx); ok {

		// Check if the owner is the one who cloned it
		if o != nil && o.IsOwner(userinfo) {
			return o, false
		}

		// Not the same owner, we now need new ownership.
		// This works for public volumes also.
		return OwnershipSetUsernameFromContext(ctx, nil), true
	}

	return o, false
}
403548
func (_ENSRegistry *ENSRegistryCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
	var (
		ret0 = new(common.Address)
	)
	out := ret0
	err := _ENSRegistry.contract.Call(opts, out, "owner", node)
	return *ret0, err
}
48135
func NewOwner(keyID string, ref blob.Ref) *Owner {
	return &Owner{
		keyID:       []string{keyID},
		blobByKeyID: map[string]SignerRefSet{keyID: SignerRefSet{ref.String()}},
	}
}
353145
func (s *ActionTypeId) SetOwner(v string) *ActionTypeId {
	s.Owner = &v
	return s
}
965902
func (s *CacheSecurityGroup) SetOwnerId(v string) *CacheSecurityGroup {
	s.OwnerId = &v
	return s
}
76913
func OwnerPermissions(orgID ID) []Permission {
	ps := []Permission{}
	for _, r := range AllResourceTypes {
		for _, a := range actions {
			if r == OrgsResourceType {
				ps = append(ps, Permission{Action: a, Resource: Resource{Type: r, ID: &orgID}})
				continue
			}
			ps = append(ps, Permission{Action: a, Resource: Resource{Type: r, OrgID: &orgID}})
		}
	}
	return ps
}
1192670
func (o *Owner) KeyID() string {
	if o == nil || len(o.keyID) == 0 {
		return ""
	}
	return o.keyID[0]
}
672582
func (tpm *TPM) TakeOwnership(srk *Key) error {
	err := tspiError(C.Tspi_TPM_TakeOwnership(tpm.handle, srk.handle, 0))
	return err
}
1037810
func (o *PostIPAMIPParams) WithOwner(owner *string) *PostIPAMIPParams {
	o.SetOwner(owner)
	return o
}
1226680
func NewOwnerManager(etcdCli *clientv3.Client, prompt, id, key string, cancel context.CancelFunc) Manager {
	logPrefix := fmt.Sprintf("[%s] %s ownerManager %s", prompt, key, id)
	return &ownerManager{
		etcdCli:   etcdCli,
		id:        id,
		key:       key,
		prompt:    prompt,
		cancel:    cancel,
		logPrefix: logPrefix,
		logCtx:    logutil.WithKeyValue(context.Background(), "owner info", logPrefix),
	}
}