Creates this directory vi the Algorithmia Data API
@param forceDelete forces deletion of the directory even if it still has other files in it
@throws APIException if there were any problems communicating with the Algorithmia API
320555
public void delete(boolean forceDelete) throws APIException {
        HttpResponse response = client.delete(getUrl() + "?force=" + forceDelete);
        HttpClientHelpers.throwIfNotOk(response);
    }
937515
public function beforeDelete( $forced = false )
  {
    try {
      \DB::table(static::$app['config']->get('workflow::nodes_table'))->where('flow_id', $this->id)->delete();
    } catch(Execption $e) {}

    return true;
  }
1210304
public static void create( String baseName ,
                               File dataFolder ,
                               int blockCount ,
                               int blockSize ,
                               boolean forceSync ) throws DataStoreException
    {
        if (blockCount <= 0)
            throw new DataStoreException("Block count should be > 0");
        if (blockSize <= 0)
            throw new DataStoreException("Block size should be > 0");
        
        File atFile = new File(dataFolder,baseName+AbstractBlockBasedDataStore.ALLOCATION_TABLE_SUFFIX);
        File dataFile = new File(dataFolder,baseName+AbstractBlockBasedDataStore.DATA_FILE_SUFFIX);
        if (atFile.exists())
            throw new DataStoreException("Cannot create store filesystem : "+atFile.getAbsolutePath()+" already exists");
        if (dataFile.exists())
            throw new DataStoreException("Cannot create store filesystem : "+dataFile.getAbsolutePath()+" already exists");
        
        initAllocationTable(atFile,
                            blockCount,
                            blockSize,
                            forceSync);
        initDataFile(dataFile,
                     blockCount,
                     blockSize,
                     forceSync);
    }
485137
public JsonResponse apiDelete(ApiAction action, Map<String, Object> data) throws IOException {
        return httpRequestJson(action, HttpRequestMethod.DELETE, data);
    }
859646
public function removeChild($position = null, $forceDelete = false)
    {
        if ($this->exists) {
            $action = ($forceDelete === true ? 'forceDelete' : 'delete');

            $this->children($position)->$action();
        }

        return $this;
    }
826945
public static Promise<Void> createDirectory(Executor executor, Path dir, @Nullable FileAttribute<?>[] attrs) {
		return ofBlockingRunnable(executor, () -> {
			try {
				Files.createDirectory(dir, attrs == null ? new FileAttribute<?>[0] : attrs);
			} catch (IOException e) {
				throw new UncheckedException(e);
			}
		});
	}
727964
public static base_responses delete(nitro_service client, appfwlearningdata resources[]) throws Exception {
		base_responses result = null;
		if (resources != null && resources.length > 0) {
			appfwlearningdata deleteresources[] = new appfwlearningdata[resources.length];
			for (int i=0;i<resources.length;i++){
				deleteresources[i] = new appfwlearningdata();
				deleteresources[i].profilename = resources[i].profilename;
				deleteresources[i].starturl = resources[i].starturl;
				deleteresources[i].cookieconsistency = resources[i].cookieconsistency;
				deleteresources[i].fieldconsistency = resources[i].fieldconsistency;
				deleteresources[i].formactionurl_ffc = resources[i].formactionurl_ffc;
				deleteresources[i].crosssitescripting = resources[i].crosssitescripting;
				deleteresources[i].formactionurl_xss = resources[i].formactionurl_xss;
				deleteresources[i].sqlinjection = resources[i].sqlinjection;
				deleteresources[i].formactionurl_sql = resources[i].formactionurl_sql;
				deleteresources[i].fieldformat = resources[i].fieldformat;
				deleteresources[i].formactionurl_ff = resources[i].formactionurl_ff;
				deleteresources[i].csrftag = resources[i].csrftag;
				deleteresources[i].csrfformoriginurl = resources[i].csrfformoriginurl;
				deleteresources[i].xmldoscheck = resources[i].xmldoscheck;
				deleteresources[i].xmlwsicheck = resources[i].xmlwsicheck;
				deleteresources[i].xmlattachmentcheck = resources[i].xmlattachmentcheck;
				deleteresources[i].totalxmlrequests = resources[i].totalxmlrequests;
			}
			result = delete_bulk_request(client, deleteresources);
		}
		return result;
	}
52139
def force_delete(self):
        
        self.__force_deleting__ = True

        self.delete()

        self.__force_deleting__ = False
172103
public File createDirectorySync(String prefix) throws IOException {
		Path path = Files.createTempDirectory(tempDir.toPath(), this.prefix + prefix);
		File dir = path.toFile();
		/*
		app.toClose(new Closeable() {
			@Override
			public void close() {
				new RemoveDirectoryTask(dir, null, 0, null, Task.PRIORITY_NORMAL, false).start();
			}
		});*/
		return dir;
	}
1233608
@Override
	public void generateAPIFiles(List<ApiImplementor> implementors) throws IOException {
		// Generate index first
		this.generateWikiIndex();
		for (ApiImplementor imp : implementors) {
			this.generateAPIFiles(imp);
		}
		this.methods = 0;
		this.generateWikiFull();
		System.out.println("Generated a total of " + methods + " methods");
	}
1006084
public void initDriverFromFile(File dbfFile, String forceEncoding) throws IOException {
        // Read columns from files metadata
        this.dbfFile = dbfFile;
        FileInputStream fis = new FileInputStream(dbfFile);
        dbaseFileReader = new DbaseFileReader(fis.getChannel(), forceEncoding);
    }
989428
public static <T extends File> T createFile(final SecurityContext securityContext, final byte[] fileData, final String contentType, final Class<T> t)
		throws FrameworkException, IOException {

		return createFile(securityContext, fileData, contentType, t, null, true);

	}
451015
public void create() throws APIException {
        CreateDirectoryRequest reqObj = new CreateDirectoryRequest(this.getName(), null);
        Gson gson = new Gson();
        JsonElement inputJson = gson.toJsonTree(reqObj);

        String url = this.getParent().getUrl();
        HttpResponse response = this.client.post(url, new StringEntity(inputJson.toString(), ContentType.APPLICATION_JSON));
        HttpClientHelpers.throwIfNotOk(response);
    }
905231
private void internalDeserialize(boolean forced) {
        if (!forced && loaded) {
            return;
        }
        
        lockDescendants(false);
        removeChildren();
        loaded = true;
        
        try {
            if (linked) {
                checkForCircularReference();
            }
            
            getLayout().materialize(this);
            
            if (linked) {
                lockDescendants(true);
            }
        } catch (Exception e) {
            CWFException.raise("Error loading layout.", e);
        }
    }
75203
@Nonnull
  public static FileIOError deleteFileIfExisting (@Nonnull final Path aFile)
  {
    final FileIOError aError = deleteFile (aFile);
    if (aError.getErrorCode ().equals (EFileIOErrorCode.SOURCE_DOES_NOT_EXIST))
      return aError.withoutErrorCode ();
    return aError;
  }
411205
private void rawCreateFolder( CPath path )
            throws CStorageException
    {
        CResponse response = null;
        try {
            String url = getObjectUrl( path );
            HttpPut request = new HttpPut( url );
            request.addHeader( "Content-Type", CONTENT_TYPE_DIRECTORY );

            RequestInvoker<CResponse> ri = getApiRequestInvoker( request, path );
            response = retryStrategy.invokeRetry( ri );

        } finally {
            PcsUtils.closeQuietly( response );
        }
    }
1094751
def delete_folder(self, id, force=None):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # OPTIONAL - force
        """Set to 'true' to allow deleting a non-empty folder"""
        if force is not None:
            params["force"] = force

        self.logger.debug("DELETE /api/v1/folders/{id} with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("DELETE", "/api/v1/folders/{id}".format(**path), data=data, params=params, no_data=True)