Java FileType.IMAGINARY属性代码示例

public FileType getFileType(String filename) throws KettleJobException
 {
try {
	SftpATTRS attrs=c.stat(filename);
		if (attrs == null)	return FileType.IMAGINARY;
		
		if ((attrs.getFlags() & SftpATTRS.SSH_FILEXFER_ATTR_PERMISSIONS) == 0)
			throw new KettleJobException("Unknown permissions error");

		if (attrs.isDir())
			return FileType.FOLDER;
		else
			return FileType.FILE;
} catch (Exception e) {
		throw new KettleJobException(e);
	}
}
 

/**
    * Determines the type of the file, returns null if the file does not
    * exist.
    */
   protected FileType doGetType() throws Exception
   {
	if (part == null)
	{
		return FileType.IMAGINARY;
	}

	if (isMultipart())
	{
		// we cant have children ...
		return FileType.FILE_OR_FOLDER;
	}

	return FileType.FILE;
}
 

/**
 * Returns the file's type.
 */
protected FileType doGetType()
    throws Exception
{
    // JDK BUG: 6192331
    // if (!file.exists())
    if (!file.exists() && file.length() < 1)
    {
        return FileType.IMAGINARY;
    }

    if (file.isDirectory())
    {
        return FileType.FOLDER;
    }

    // In doubt, treat an existing file as file
    // if (file.isFile())
    // {
        return FileType.FILE;
    // }

    // throw new FileSystemException("vfs.provider.local/get-type.error", file);
}
 

/**
 * Determines the type of this file.  Must not return null.  The return
 * value of this method is cached, so the implementation can be expensive.
 */
protected FileType doGetType()
    throws Exception
{
    // Use the HEAD method to probe the file.
    method = new HeadMethod();
    setupMethod(method);
    final HttpClient client = fileSystem.getClient();
    final int status = client.executeMethod(method);
    method.releaseConnection();
    if (status == HttpURLConnection.HTTP_OK)
    {
        return FileType.FILE;
    }
    else if (status == HttpURLConnection.HTTP_NOT_FOUND
        || status == HttpURLConnection.HTTP_GONE)
    {
        return FileType.IMAGINARY;
    }
    else
    {
        throw new FileSystemException("vfs.provider.http/head.error", getName());
    }
}
 

/**
 * Determines the type of the file, returns null if the file does not
 * exist.
 */
protected FileType doGetType() throws FileSystemException
{
    if (file != null)
    {
        return file.getType();
    }
    else if (children.size() > 0)
    {
        return FileType.FOLDER;
    }
    else
    {
        return FileType.IMAGINARY;
    }
}
 

@Override
protected FileType doGetType() throws Exception {
    synchronized (proactiveFS) {
        if (fileInfo.getType() == null) {
            return FileType.IMAGINARY;
        }

        switch (fileInfo.getType()) {
            case FILE:
                return FileType.FILE;
            case DIRECTORY:
                return FileType.FOLDER;
            default:
                throw new RuntimeException("Unexpected file type");
        }
    }
}
 

private Part findPart(String partName) throws Exception
{
	if (getType() == FileType.IMAGINARY)
	{
		// not existent
		return null;
	}

	if (isMultipart())
	{
		Multipart multipart = (Multipart)  part.getContent();
		if (partName.startsWith(MimeFileSystem.NULL_BP_NAME))
		{
			int partNumber = Integer.parseInt(partName.substring(MimeFileSystem.NULL_BP_NAME.length()), 10);
			if (partNumber < 0 || partNumber+1 > multipart.getCount())
			{
				// non existent
				return null;
			}

			return multipart.getBodyPart(partNumber);
		}

		for (int i = 0; i<multipart.getCount(); i++)
		{
			Part childPart = multipart.getBodyPart(i);
			if (partName.equals(childPart.getFileName()))
			{
				return childPart;
			}
		}
	}

	return null;
}
 

protected ZipFileObject(FileName name,
                        ZipEntry entry,
                        ZipFileSystem fs,
                        boolean zipExists) throws FileSystemException
{
    super(name, fs);
    this.fs = fs;
    setZipEntry(entry);
    if (!zipExists)
    {
        type = FileType.IMAGINARY;
    }
}
 

/**
 *
 */
void clear()
{
    this.buffer = new byte[0];
    updateLastModified();
    this.type = FileType.IMAGINARY;
    this.children = Collections.synchronizedCollection(new ArrayList());
    this.name = null;
}
 

/**
 * Determines the type of the file, returns null if the file does not
 * exist.
 */
protected FileType doGetType()
    throws Exception
{
    // VFS-210
    synchronized (getFileSystem())
    {
        if (this.fileInfo == null)
        {
            getInfo(false);
        }

        if (this.fileInfo == UNKNOWN)
        {
            return FileType.IMAGINARY;
        }
        else if (this.fileInfo.isDirectory())
        {
            return FileType.FOLDER;
        }
        else if (this.fileInfo.isFile())
        {
            return FileType.FILE;
        }
        else if (this.fileInfo.isSymbolicLink())
        {
            return getLinkDestination().getType();
        }
    }

    throw new FileSystemException("vfs.provider.ftp/get-type.error", getName());
}
 

protected TarFileObject(FileName name,
                        TarEntry entry,
                        TarFileSystem fs,
                        boolean tarExists) throws FileSystemException
{
    super(name, fs);
    this.fs = fs;
    setTarEntry(entry);
    if (!tarExists)
    {
        type = FileType.IMAGINARY;
    }
}
 

/**
 * Determines the type of the file.
 */
protected FileType doGetType() throws Exception
{
    try
    {
        // Attempt to connect & check status
        final URLConnection conn = url.openConnection();
        final InputStream in = conn.getInputStream();
        try
        {
            if (conn instanceof HttpURLConnection)
            {
                final int status = ((HttpURLConnection) conn).getResponseCode();
                // 200 is good, maybe add more later...
                if (HttpURLConnection.HTTP_OK != status)
                {
                    return FileType.IMAGINARY;
                }
            }

            return FileType.FILE;
        }
        finally
        {
            in.close();
        }
    }
    catch (final FileNotFoundException e)
    {
        return FileType.IMAGINARY;
    }
}
 

/**
 * Checks whether the file's type has changed, and fires the appropriate
 * events.
 * @param oldType The old FileType.
 * @throws Exception if an error occurs.
 */
private void maybeTypeChanged(final FileType oldType) throws Exception
{
    final FileType newType = doGetType();
    if (oldType == FileType.IMAGINARY && newType != FileType.IMAGINARY)
    {
        handleCreate(newType);
    }
    else if (oldType != FileType.IMAGINARY && newType == FileType.IMAGINARY)
    {
        handleDelete();
    }
}
 

/**
 * Called when the ouput stream for this file is closed.
 */
protected void endOutput() throws Exception
{
    if (getType() == FileType.IMAGINARY)
    {
        // File was created
        handleCreate(FileType.FILE);
    }
    else
    {
        // File has changed
        onChange();
    }
}
 

private void setFileType(FileType type)
{
    if (type != null && type != FileType.IMAGINARY)
    {
        try
        {
            name.setType(type);
        }
        catch (FileSystemException e)
        {
            throw new RuntimeException(e.getMessage());
        }
    }
    this.type = type;
}