org-netbeans-modules-masterfs

ows IOException
  {
    getPreferedAttributes().writeAttribute(translateName(paramString1), paramString2, paramObject);
  }
  
  public synchronized Enumeration<String> attributes(String paramString)
  {
    Enumeration localEnumeration = getPreferedAttributes().attributes(translateName(paramString));
    if (((localEnumeration == null) || (!localEnumeration.hasMoreElements())) && (isBackwardCompatible())) {
      localEnumeration = copyAllToUserDir(paramString, super.attributes(paramString));
    }
    return localEnumeration;
  }
  
  private Enumeration<String> copyAllToUserDir(String paramString, Enumeration<String> paramEnumeration)
  {
    if ((paramEnumeration != null) && (paramEnumeration.hasMoreElements()) && (isBackwardCompatible()))
    {
      String str1 = translateName(paramString);
      while (paramEnumeration.hasMoreElements())
      {
        String str2 = (String)paramEnumeration.nextElement();
        Object localObject = super.readAttribute(paramString, str2);
        try
        {
          getPreferedAttributes().writeAttribute(str1, str2, localObject);
        }
        catch (IOException localIOException)
        {
          Exceptions.printStackTrace(localIOException);
        }
      }
      super.deleteAttributes(paramString);
      paramEnumeration = getPreferedAttributes().attributes(str1);
    }
    return paramEnumeration;
  }
  
  public synchronized void renameAttributes(String paramString1, String paramString2)
  {
    if (isBackwardCompatible()) {
      copyAllToUserDir(paramString1, super.attributes(paramString1));
    }
    getPreferedAttributes().renameAttributes(translateName(paramString1), translateName(paramString2));
  }
  
  public synchronized void deleteAttributes(String paramString)
  {
    if (isBackwardCompatible()) {
      super.deleteAttributes(paramString);
    }
    getPreferedAttributes().deleteAttributes(translateName(paramString));
  }
  
  private String translateName(String paramString)
  {
    return attributePrefix + paramString;
  }
  
  private DefaultAttributes getPreferedAttributes()
  {
    synchronized (Attributes.class)
    {
      if (sharedUserAttributes == null)
      {
        ExLocalFileSystem localExLocalFileSystem = null;
        try
        {
          localExLocalFileSystem = ExLocalFileSystem.getInstance(getRootForAttributes());
        }
        catch (PropertyVetoException localPropertyVetoException)
        {
          Exceptions.printStackTrace(localPropertyVetoException);
        }
        catch (IOException localIOException)
        {
          Exceptions.printStackTrace(localIOException);
        }
        sharedUserAttributes = localExLocalFileSystem.getAttributes();
      }
    }
    assert (sharedUserAttributes != null);
    return sharedUserAttributes != null ? sharedUserAttributes : this;
  }
  
  private boolean isBackwardCompatible()
  {
    return false;
  }
}

/* Location:
 * Qualified Name:     org.netbeans.modules.masterfs.providers.Attributes
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.netbeans.modules.masterfs.providers;

import org.openide.filesystems.FileObject;

public abstract interface InterceptionListener
{
  public abstract void beforeCreate(FileObject paramFileObject, String paramString, boolean paramBoolean);
  
  public abstract void createSuccess(FileObject paramFileObject);
  
  public abstract void createFailure(FileObject paramFileObject, String paramString, boolean paramBoolean);
  
  public abstract void beforeDelete(FileObject paramFileObject);
  
  public abstract void deleteSuccess(FileObject paramFileObject);
  
  public abstract void deleteFailure(FileObject paramFileObject);
}

/* Location:
 * Qualified Name:     org.netbeans.modules.masterfs.providers.InterceptionListener
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.netbeans.modules.masterfs.providers;

import java.io.File;

public abstract interface ProvidedExtensions$DeleteHandler
{
  public abstract boolean delete(File paramFile);
}

/* Location:
 * Qualified Name:     org.netbeans.modules.masterfs.providers.ProvidedExtensions.DeleteHandler
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.netbeans.modules.masterfs.providers;

import java.io.IOException;

public abstract interface ProvidedExtensions$IOHandler
{
  public abstract void handle()
    throws IOException;
}

/* Location:
 * Qualified Name:     org.netbeans.modules.masterfs.providers.ProvidedExtensions.IOHandler
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package org.netbeans.modules.masterfs.providers;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.Callable;
import org.netbeans.modules.masterfs.filebasedfs.utils.FileChangedManager;
import org.openide.filesystems.FileObject;

public class ProvidedExtensions
  implements InterceptionListener
{
  public IOHandler getMoveHandler(File paramFile1, File paramFile2)
  {
    return null;
  }
  
  public IOHandler getRenameHandler(File paramFile, String paramString)
  {
    return null;
  }
  
  public DeleteHandler getDeleteHandler(File paramFile)
  {
    return null;
  }
  
  public void createSuccess(FileObject paramFileObject) {}
  
  public void createFailure(FileObject paramFileObject, String paramString, boolean paramBoolean) {}
  
  public void beforeCreate(FileObject paramFileObject, String paramString, boolean paramBoolean) {}
  
  public void deleteSuccess(FileObject paramFileObject) {}
  
  public void deleteFailure(FileObject paramFileObject) {}
  
  public void beforeDelete(FileObject paramFileObject) {}
  
  public boolean canWrite(File paramFile)
  {
    return paramFile.canWrite();
  }
  
  public void beforeChange(FileObject paramFileObject) {}
  
  public void fileLocked(FileObject paramFileObject) {}
  
  public void fileUnlocked(FileObject paramFileObject) {}
  
  public Object getAttribute(File paramFile, String paramString)
  {
    return null;
  }
  
  public long refreshRecursively(File paramFile, long paramLong, List<? super File> paramList)
  {
    return -1L;
  }
  
  public static <T> T priorityIO(Callable<T> paramCallable)
    throws Exception
  {
    return (T)FileChangedManager.priorityIO(paramCallable);
  }
  
  public static abstract interface DeleteHandler
  {
    public abstract boolean delete(File paramFile);
  }
  
  public static abstract interface IOHandler
  {
    public abstract void handle()
      throws IOException;
  }
}

/* Location:
 * Qualified Name:     org.netbeans.modules.masterfs.providers.ProvidedExtensions
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
1 2 3 4 5 6 7 8

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd