// SetReleaseDate sets the ReleaseDate field's value.
489791
func (s *Patch) SetReleaseDate(v time.Time) *Patch {
	s.ReleaseDate = &v
	return s
}
1207226
func (s *VolumeStore) Release(ctx context.Context, name string, ref string) error {
	s.locks.Lock(name)
	defer s.locks.Unlock(name)
	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}

	s.globalLock.Lock()
	defer s.globalLock.Unlock()

	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}

	if s.refs[name] != nil {
		delete(s.refs[name], ref)
	}
	return nil
}
51548
func (s *Workteam) SetCreateDate(v time.Time) *Workteam {
	s.CreateDate = &v
	return s
}
1281329
func (s *InstanceProfile) SetCreateDate(v time.Time) *InstanceProfile {
	s.CreateDate = &v
	return s
}
832394
func (lk *etcdLock) Release() error {
	keyName := "/contiv.io/lock/" + lk.name

	lk.mutex.Lock()
	defer lk.mutex.Unlock()

	// Mark this as released
	lk.isReleased = true

	// Send stop signal on stop channel
	lk.stopChan <- true

	// If the lock was acquired, release it
	if lk.isAcquired {
		// Delete the lock entry
		resp, err := lk.kapi.Delete(context.Background(), keyName, &client.DeleteOptions{PrevValue: lk.myID})
		if err != nil {
			log.Errorf("Error Deleting key. Err: %v", err)
		} else {
			log.Infof("Deleted key lock %s, Resp: %+v", keyName, resp)
		}

		lk.isAcquired = false
	}

	return nil
}
531190
func (s *GroupDetail) SetCreateDate(v time.Time) *GroupDetail {
	s.CreateDate = &v
	return s
}
1245768
func (s *GetOpenIDConnectProviderOutput) SetCreateDate(v time.Time) *GetOpenIDConnectProviderOutput {
	s.CreateDate = &v
	return s
}
375313
func (client *Client) SetRelease(release string) {
	client.mu.Lock()
	defer client.mu.Unlock()
	client.release = release
}
818363
func (b *Bytes) Release() {
	if b.pool != nil {
		b.Reset()
		b.pool.list <- b
	}
}
860395
func (c *Certificate) SetExpireDate(when time.Duration) error {
	offset := C.long(when / time.Second)
	result := C.X509_gmtime_adj(C.X_X509_get0_notAfter(c.x), offset)
	if result == nil {
		return errors.New("failed to set expire date")
	}
	return nil
}
639584
func (r *AllocationBitmap) Release(offset int) error {
	r.lock.Lock()
	defer r.lock.Unlock()

	if r.allocated.Bit(offset) == 0 {
		return nil
	}

	r.allocated = r.allocated.SetBit(r.allocated, offset, 0)
	r.count--
	return nil
}
452121
func (d *DeviceMapperDriver) Release(volumeName string) error {
	glog.V(2).Infof("Release() (%s) START", volumeName)
	defer glog.V(2).Infof("Release() (%s) END", volumeName)
	vol, err := d.getVolume(volumeName, false)
	if err != nil {
		return err
	}
	if mounted, _ := devmapper.Mounted(vol.Path()); mounted {
		glog.V(1).Infof("Unmounting %s", volumeName)
		if err := vol.unmount(); err != nil {
			glog.Errorf("Error whilst unmounting %s: %s", vol.path, err)
			return err
		}
	}
	deviceHashes := vol.Metadata.ListDevices()
	for _, deviceHash := range deviceHashes {
		if deviceHash == "" {
			// this can happen when all previously active devices have been deactivated
			continue
		}

		// Perversely, DeactivateDevice() will not actually work unless the device is activated.
		// GetDeviceStatus() will both verify that device is valid, and it has the side-effect of activating
		// the device if the device is not active.
		if status, err := d.DeviceSet.GetDeviceStatus(deviceHash); err != nil {
			glog.Errorf("For volume %s, unable to get status for device %q: %s", volumeName, deviceHash, err)
			continue
		} else if status == nil {
			glog.V(2).Infof("For volume %s, no status available for device %q", volumeName, deviceHash)
		} else {
			glog.V(2).Infof("For volume %s, status for device %q: %v", volumeName, deviceHash, status)
		}

		glog.V(1).Infof("Deactivating device (%s)", deviceHash)
		d.DeviceSet.Lock()
		err := d.DeactivateDevice(deviceHash)
		d.DeviceSet.Unlock()
		if err != nil {
			glog.Errorf("Error removing device %q for volume %s: %s", deviceHash, volumeName, err)
			return err
		}
		glog.V(2).Infof("Deactivated device")
	}
	return nil
}
960964
func (s *PolicyVersion) SetCreateDate(v time.Time) *PolicyVersion {
	s.CreateDate = &v
	return s
}
1172276
func (s *Namespace) SetCreateDate(v time.Time) *Namespace {
	s.CreateDate = &v
	return s
}
119583
func WithRelease(release string) func(*client) {
	return func(c *client) {
		c.c.SetRelease(release)
	}
}
393091
func (r *Route) Release() {
	if r.ref != nil {
		r.ref.decRef()
		r.ref = nil
	}
}
181679
func (a *allocator) release(n int) {
	a.pool.SetBit(a.pool, n-a.low, free)
}