Java FileObject.canWrite方法代码示例

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
 */
@Override
public boolean searchFile(FileObject file)
        throws IllegalArgumentException {
    if (file.isFolder()) {
        throw new java.lang.IllegalArgumentException(
                "file (not folder) expected");                      //NOI18N
    }
    File f = FileUtil.toFile(file);
    if (f == null && !file.canWrite()) {
        // non-standard file objects, e.g. ZIP archive items.
        return true;
    } else {
        return SharabilityQuery.getSharability(file)
                != Sharability.NOT_SHARABLE;
    }
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
 */
@Override
public FolderResult traverseFolder(FileObject folder)
        throws IllegalArgumentException {
    if (!folder.isFolder()) {
        throw new java.lang.IllegalArgumentException(
                "folder expected");                                 //NOI18N
    }
    File f = FileUtil.toFile(folder);
    if (f == null && !folder.canWrite()) {
        // non-standard file objects, e.g. ZIP archive items.
        return FolderResult.TRAVERSE;
    } else {
        Sharability sharability = SharabilityQuery.getSharability(folder);
        switch (sharability) {
            case NOT_SHARABLE:
                return FolderResult.DO_NOT_TRAVERSE;
            case SHARABLE:
                return FolderResult.TRAVERSE_ALL_SUBFOLDERS;
            default:
                return FolderResult.TRAVERSE;
        }
    }
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
 */
@Override
public int traverseFolder(FileObject folder)
        throws IllegalArgumentException {
    if (!folder.isFolder()) {
        throw new java.lang.IllegalArgumentException(
                "folder expected");                                 //NOI18N
    }
    File f = FileUtil.toFile(folder);
    if (f == null && !folder.canWrite()) {
        // non-standard file objects, e.g. ZIP archive items.
        return TRAVERSE;
    } else {
        final int sharability = SharabilityQuery.getSharability(f);
        switch (sharability) {
            case SharabilityQuery.NOT_SHARABLE:
                return DO_NOT_TRAVERSE;
            case SharabilityQuery.SHARABLE:
                return TRAVERSE_ALL_SUBFOLDERS;
            default:
                return TRAVERSE;
        }
    }
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
 * Checks whether the folder identified by the given <code>packageName</code> is
 * writable or is in a writable parent directory but does not exist yet.
 * 
 * @param sourceGroup the source group of the folder; must not be null.
 * @param packageName the package to check; must not be null.
 * @return true if the folder is writable or can be created (i.e. the parent 
 * folder, or the root folder of the given <code>sourceGroup</code> if there is no other 
 * parent for the folder, is writable), false otherwise.
 */ 
public static boolean isFolderWritable(SourceGroup sourceGroup, String packageName) {
    Parameters.notNull("sourceGroup", sourceGroup); //NOI18N
    Parameters.notNull("packageName", packageName); //NOI18N
    try {
        FileObject fo = getFolderForPackage(sourceGroup, packageName, false);

        while ((fo == null) && (packageName.lastIndexOf('.') != -1)) {
            packageName = packageName.substring(0, packageName.lastIndexOf('.'));
            fo = getFolderForPackage(sourceGroup, packageName, false);
        }
        return fo == null ? sourceGroup.getRootFolder().canWrite() : fo.canWrite();
    } catch (IOException ex) {
        LOGGER.log(Level.INFO, null, ex);
        return false;
    }
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
 */
@Override
public boolean searchFile(FileObject file)
        throws IllegalArgumentException {
    if (file.isFolder()) {
        throw new java.lang.IllegalArgumentException(
                "file (not folder) expected");                      //NOI18N
    }
    File f = FileUtil.toFile(file);
    if (f == null && !file.canWrite()) {
        // non-standard file objects, e.g. ZIP archive items.
        return true;
    } else {
        return SharabilityQuery.getSharability(FileUtil.toFile(file))
                != SharabilityQuery.NOT_SHARABLE;
    }
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
private void checkFileStatus(FileObject fo) {
    boolean update = false;
    synchronized (this) {
        if (lastFile == null || lastFile.get() != fo) {
            lastFile = new WeakReference<FileObject>(fo);
            update = true;
        }
    }
    if (update) {
        fo.addFileChangeListener(WeakListeners.create(FileChangeListener.class, this, fo));
        boolean readOnly = !fo.canWrite(); // Access without monitor on this class and document's lock
        updateFileReadOnly(readOnly);
    }
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
 * Returns true if the underlying document is read-only, false otherwise.
 */
public boolean isReadOnly() {
    ModelSource ms = getModelSource();
    assert(ms != null);
    if (ms.isEditable()) {
        FileObject fo = (FileObject) ms.getLookup().lookup(FileObject.class);
        assert(fo != null);
        return !fo.canWrite();
    }
    return true;
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
private boolean isBaseFileWritable () {
    if (canWriteBaseFile == null) {
        FileObject fo = FileUtil.toFileObject(baseFile);
        canWriteBaseFile = fo != null && fo.canWrite();
    }
    return canWriteBaseFile;
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
public static Set<Severity> disableErrors(FileObject file) {
    if (file.getAttribute(DISABLE_ERRORS) != null) {
        return EnumSet.allOf(Severity.class);
    }
    if (!file.canWrite() && FileUtil.getArchiveFile(file) != null) {
        return EnumSet.allOf(Severity.class);
    }

    return EnumSet.noneOf(Severity.class);
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
public void testImplsCanWrite() throws IOException {
    FileObject fo = FileUtil.toFileObject(getWorkDir());
    assertNotNull(fo);
    assertNotNull(iListener);
    assertNotNull(iListenerNoCanWrite);
    int nCalls = iListener.implsCanWriteCalls;
    FileObject toChange = fo.createData("cw");
    assertNotNull(toChange);
    boolean cw = toChange.canWrite();
    assertEquals(nCalls + 1, iListener.implsCanWriteCalls);
    assertEquals(0, iListenerNoCanWrite.implsCanWriteCalls);
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
public void implement() throws Exception {
    final FileObject file = err.getFile();
    if (!file.canWrite()) {
        NotifyDescriptor d = new NotifyDescriptor.Message(
                NbBundle.getMessage(FixDescription.class, "CTL_File_Not_Writable", file.getNameExt()), //NOI18N
                NotifyDescriptor.ERROR_MESSAGE);
        DialogDisplayer.getDefault().notify(d);
        return ;
    }

    fix.implement();
    fixed.set(true);
    cs.fireChange();
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
/**
    * Detects if targets file is non-null and writable
    * @return true if target's file is writable
    */
   public static boolean isTargetWritable(@NonNull TypeElement target, @NonNull CompilationInfo info) {
       TypeElement outermostType = info.getElementUtilities().outermostTypeElement(target);
       FileObject fo = SourceUtils.getFile(ElementHandle.create(outermostType), info.getClasspathInfo());
if(fo != null && fo.canWrite())
    return true;
else
    return false;
   }
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
@Messages({
     "MSG_SaveModified=File {0} is modified. Save?"
 })
 @Override
 public CloseOperationState canCloseElement() {
     if (sqlEditorSupport().isConsole()) {
         return CloseOperationState.STATE_OK;
     } else {
         DataObject sqlDO = sqlEditorSupport().getDataObject();
         FileObject sqlFO = sqlEditorSupport().getDataObject().getPrimaryFile();
         if (sqlDO.isModified()) {
             if (sqlFO.canWrite()) {
                 Savable sav = sqlDO.getLookup().lookup(Savable.class);
                 if (sav != null) {
                     AbstractAction save = new AbstractAction() {
                         @Override
                         public void actionPerformed(ActionEvent e) {
                             try {
                                 sqlEditorSupport().saveDocument();
                             } catch (IOException ex) {
                                 Exceptions.printStackTrace(ex);
                             }
                         }
                     };
                     save.putValue(Action.LONG_DESCRIPTION, Bundle.MSG_SaveModified(sqlFO.getNameExt()));
                     return MultiViewFactory.createUnsafeCloseState("editor", save, null);
                 }
             }
         }
     }
     return CloseOperationState.STATE_OK;
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
public boolean isReadOnly() {
    FileObject javaFO = getPrimaryFile();
    FileObject formFO = formEntry.getFile();
    return !javaFO.canWrite() || !formFO.canWrite();
}
 

import org.openide.filesystems.FileObject; //导入方法依赖的package包/类
protected void performAction(Node[] nodes) {
    Node node = nodes[ 0 ];
    FileObject fo = node.getLookup().lookup( FileObject.class );
    Project proj = node.getLookup().lookup(Project.class);
    String origLoc = (String) node.getValue(
            JAXBWizModuleConstants.ORIG_LOCATION);
    Boolean origLocIsURL = (Boolean) node.getValue(
            JAXBWizModuleConstants.ORIG_LOCATION_TYPE);
    FileObject locSchemaRoot = (FileObject) node.getValue(
            JAXBWizModuleConstants.LOC_SCHEMA_ROOT);
    
    if ( ( fo != null ) && ( origLoc != null ) ) {
        // XXX TODO run in separate non-awt thread.
         try {
             if (fo.canWrite()){
                 if (origLocIsURL){
                    URL url = new URL(origLoc);
                     ProjectHelper.retrieveResource(locSchemaRoot, 
                             url.toURI());                        
                 } else {
                     File projDir = FileUtil.toFile(
                             proj.getProjectDirectory());
                     //File srcFile = new File(origLoc);
                     File srcFile = FileSysUtil.Relative2AbsolutePath(
                             projDir, origLoc);
                     ProjectHelper.retrieveResource(fo.getParent(), 
                             srcFile.toURI());
                 }
             } else {
                 String msg = NbBundle.getMessage(this.getClass(),
                         "MSG_CanNotRefreshFile"); //NOI18N
                 NotifyDescriptor d = new NotifyDescriptor.Message(
                         msg, NotifyDescriptor.INFORMATION_MESSAGE);
                 d.setTitle(NbBundle.getMessage(this.getClass(), 
                         "LBL_RefreshFile")); //NOI18N
                 DialogDisplayer.getDefault().notify(d);
             }
         } catch (Exception ex){
             log(ex);
         } 
    }
}