Delete a management lock by scope.

@param scope The scope for the lock.
@param lockName The name of lock.
@throws IllegalArgumentException thrown if parameters fail the validation
@return the {@link ServiceResponse} object if successful.
346687
public Observable<Void> deleteByScopeAsync(String scope, String lockName) {
        return deleteByScopeWithServiceResponseAsync(scope, lockName).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }
123345
public Observable<Page<RoleAssignmentInner>> listForScopeAsync(final String scope) {
        return listForScopeWithServiceResponseAsync(scope)
            .map(new Func1<ServiceResponse<Page<RoleAssignmentInner>>, Page<RoleAssignmentInner>>() {
                @Override
                public Page<RoleAssignmentInner> call(ServiceResponse<Page<RoleAssignmentInner>> response) {
                    return response.body();
                }
            });
    }
865596
def delete_by_scope(scope, lock_name, custom_headers:nil)
      response = delete_by_scope_async(scope, lock_name, custom_headers:custom_headers).value!
      nil
    end
668123
private void unregisterMBeanInService(String name) {
        ServiceRegistration<DynamicMBean> existingMBean = endpointMBeans.remove(name);
        if (existingMBean != null) {
            existingMBean.unregister();
        }
    }
902394
protected synchronized void removeAdminObjectService(ServiceReference<AdminObjectService> reference) {
        String id = (String) reference.getProperty(ADMIN_OBJECT_CFG_ID);
        if (id != null) {
            removeAdminObjectService(reference, id, false);

            String jndiName = (String) reference.getProperty(ADMIN_OBJECT_CFG_JNDI_NAME);
            if (jndiName != null && !jndiName.equals(id)) {
                removeAdminObjectService(reference, jndiName, true);
            }
        }
    }
692671
public Observable<ServiceResponse<Void>> deleteProjectWithServiceResponseAsync(UUID projectId) {
        if (projectId == null) {
            throw new IllegalArgumentException("Parameter projectId is required and cannot be null.");
        }
        if (this.client.apiKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.apiKey() is required and cannot be null.");
        }
        return service.deleteProject(projectId, this.client.apiKey(), this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteProjectDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1339084
public static base_response delete(nitro_service client, String keyname) throws Exception {
		dnskey deleteresource = new dnskey();
		deleteresource.keyname = keyname;
		return deleteresource.delete_resource(client);
	}
1324670
public static base_response delete(nitro_service client, String acl6name) throws Exception {
		nsacl6 deleteresource = new nsacl6();
		deleteresource.acl6name = acl6name;
		return deleteresource.delete_resource(client);
	}
248517
@Override
    public java.util.concurrent.Future<DeleteTableResult> deleteTableAsync(String tableName) {

        return deleteTableAsync(new DeleteTableRequest().withTableName(tableName));
    }
870986
def remove_lock(lock, key, session=None):
    
    return _request('get', '/remove/lock/{0}'.format(lock), params={'key': key}, session=session)
371165
protected synchronized void lock(ManagedObject managedObject)
                    throws ObjectManagerException
    {
        throw new InvalidStateException(this, InternalTransaction.stateTerminated, InternalTransaction.stateNames[InternalTransaction.stateTerminated]);
    }
432451
public Observable<ManagementLockObjectInner> getAtSubscriptionLevelAsync(String lockName) {
        return getAtSubscriptionLevelWithServiceResponseAsync(lockName).map(new Func1<ServiceResponse<ManagementLockObjectInner>, ManagementLockObjectInner>() {
            @Override
            public ManagementLockObjectInner call(ServiceResponse<ManagementLockObjectInner> response) {
                return response.body();
            }
        });
    }
477402
public Object remove(String name) {
		ThreadScopeContext context = ThreadScopeContextHolder.getContext();
		return context.remove(name);
	}
1029522
public Bucket lockRetentionPolicy(String bucketName) throws StorageException {
    // [START storage_lock_retention_policy]
    // Instantiate a Google Cloud Storage client
    Storage storage = StorageOptions.getDefaultInstance().getService();

    // The name of a bucket, e.g. "my-bucket"
    // String bucketName = "my-bucket";

    Bucket bucket =
        storage.get(bucketName, Storage.BucketGetOption.fields(BucketField.METAGENERATION));
    Bucket lockedBucket =
        bucket.lockRetentionPolicy(Storage.BucketTargetOption.metagenerationMatch());

    System.out.println("Retention period for " + bucketName + " is now locked");
    System.out.println(
        "Retention policy effective as of " + new Date(lockedBucket.getRetentionEffectiveTime()));
    // [END storage_lock_retention_policy]
    return lockedBucket;
  }
1090343
@Override
	public Response deleteApplication( String applicationName ) {

		this.logger.fine( "Request: delete application " + applicationName + "." );
		Response result = Response.ok().build();
		try {
			ManagedApplication ma = this.manager.applicationMngr().findManagedApplicationByName( applicationName );
			if( ma == null )
				result = handleError(
						Status.NOT_FOUND,
						new RestError( REST_INEXISTING, application( applicationName )),
						lang( this.manager )).build();
			else
				this.manager.applicationMngr().deleteApplication( ma );

		} catch( UnauthorizedActionException | IOException e ) {
			result = handleError(
					Status.FORBIDDEN,
					new RestError( REST_DELETION_ERROR, e, application( applicationName )),
					lang( this.manager )).build();
		}

		return result;
	}
1171272
public static base_response delete(nitro_service client, String servicegroupname) throws Exception {
		servicegroup deleteresource = new servicegroup();
		deleteresource.servicegroupname = servicegroupname;
		return deleteresource.delete_resource(client);
	}
249225
@Override
  public DeleteResponse execute(ObjectStoreClient objectStoreClient) throws IOException {
    objectStoreClient.delete(this.objectId, this.deleteConfig);
    return new DeleteResponse(HttpStatus.SC_ACCEPTED);
  }