Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2012 JBoss Inc
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.uberfire.io.impl;
 
 import java.util.Map;
 import java.util.Set;
 
 import  org.uberfire.java.nio.IOException;
 import  org.uberfire.java.nio.base.AbstractBasicFileAttributeView;
 import  org.uberfire.java.nio.base.AttrHolder;
 import  org.uberfire.java.nio.base.NeedsPreloadedAttrs;
 import  org.uberfire.java.nio.base.Properties;
 import  org.uberfire.java.nio.base.dotfiles.DotFileOption;
 import  org.uberfire.java.nio.channels.SeekableByteChannel;
 import  org.uberfire.java.nio.file.AtomicMoveNotSupportedException;
 import  org.uberfire.java.nio.file.CopyOption;
 import  org.uberfire.java.nio.file.DeleteOption;
 import  org.uberfire.java.nio.file.DirectoryNotEmptyException;
 import  org.uberfire.java.nio.file.FileAlreadyExistsException;
 import  org.uberfire.java.nio.file.Files;
 import  org.uberfire.java.nio.file.NoSuchFileException;
 import  org.uberfire.java.nio.file.OpenOption;
 import  org.uberfire.java.nio.file.Path;
 import  org.uberfire.java.nio.file.attribute.FileAttribute;
 import  org.uberfire.java.nio.file.attribute.FileAttributeView;
 import  org.uberfire.commons.lock.LockService;
 
 import static org.uberfire.java.nio.base.dotfiles.DotFileUtils.*;
 import static org.uberfire.java.nio.file.StandardCopyOption.*;
 import static org.uberfire.commons.validation.Preconditions.*;
 
 public class IOServiceDotFileImpl
         extends AbstractIOService
         implements IOService {
 
     public IOServiceDotFileImpl() {
         super();
     }
 
     public IOServiceDotFileImplfinal String serviceId ) {
         superserviceId );
     }
 
     public IOServiceDotFileImplfinal IOWatchService watchService ) {
         superwatchService );
     }
 
     public IOServiceDotFileImplfinal String serviceId,
                                  final IOWatchService watchService ) {
         superserviceIdwatchService );
     }
 
     public IOServiceDotFileImplfinal LockService lockService,
                                  final IOWatchService watchService ) {
         superlockServicewatchService );
     }
 
     public IOServiceDotFileImplfinal String serviceId,
                                  final LockService lockService,
                                  final IOWatchService watchService ) {
         superserviceIdlockServicewatchService );
     }
 
     @Override
     public synchronized void deletefinal Path path,
                                      final DeleteOption... options )
             throws IllegalArgumentException, NoSuchFileException, DirectoryNotEmptyException,
             IOException, SecurityException {
         Files.delete( pathoptions );
         try {
             Files.deleteIfExists( dot( path ), options );
         } catch ( Exception ex ) {
         }
         if ( path instanceof AttrHolder ) {
             ( (AttrHolder) path ).getAttrStorage().clear();
         }
     }
 
     @Override
     public synchronized boolean deleteIfExistsfinal Path path,
                                                final DeleteOption... options )
            throws IllegalArgumentException, DirectoryNotEmptyException, IOException, SecurityException {
        final boolean result = Files.deleteIfExists( pathoptions );
        try {
            Files.deleteIfExists( dot( path ), options );
        } catch ( Exception ex ) {
        }
        if ( path instanceof AttrHolder ) {
            ( (AttrHolder) path ).getAttrStorage().clear();
        }
        return result;
    }
    @Override
    public synchronized SeekableByteChannel newByteChannelfinal Path path,
                                                            final Set<? extends OpenOption> options,
                                                            final FileAttribute<?>... attrs )
            FileAlreadyExistsException, IOException, SecurityException {
        checkNotNull( "path"path );
        final Properties properties = new Properties();
        if ( exists( dot( path ) ) ) {
            properties.load( newInputStream( dot( path ) ) );
        }
        final FileAttribute<?>[] allAttrs = consolidate( propertiesattrs );
        final SeekableByteChannel result = Files.newByteChannel( pathbuildOptionsoptions ), allAttrs );
        if ( isFileSchemepath ) ) {
            buildDotFile( pathnewOutputStream( dot( path ) ), allAttrs );
        }
        return result;
    }
    @Override
    public synchronized Path createDirectoryfinal Path dir,
                                              final FileAttribute<?>... attrs )
            throws IllegalArgumentExceptionUnsupportedOperationException, FileAlreadyExistsException,
            IOException, SecurityException {
        return internalCreateDirectorydirfalseattrs );
    }
    @Override
    public synchronized Path createDirectoriesfinal Path dir,
                                                final FileAttribute<?>... attrs )
            throws UnsupportedOperationException, FileAlreadyExistsException,
            IOException, SecurityException {
        final Path result = Files.createDirectories( dirattrs );
        buildDotFile( dirnewOutputStream( dot( dir ) ), attrs );
        return result;
    }
    @Override
    public synchronized Path copyfinal Path source,
                                   final Path target,
                                   final CopyOption... options )
            throws UnsupportedOperationException, FileAlreadyExistsException,
            DirectoryNotEmptyException, IOException, SecurityException {
        if ( Files.exists( dot( source ) ) ) {
            Files.copy( dot( source ), dot( target ), forceBuildOptionsoptions ) );
        } else if ( Files.exists( dot( target ) ) ) {
            Files.delete( dot( target ) );
        }
        final Path result = Files.copy( sourcetargetoptions );
        return result;
    }
    @Override
    public synchronized Path movefinal Path source,
                                   final Path target,
                                   final CopyOption... options )
            throws UnsupportedOperationException, FileAlreadyExistsException,
            DirectoryNotEmptyException, AtomicMoveNotSupportedException, IOException, SecurityException {
        if ( Files.exists( dot( source ) ) ) {
            Files.move( dot( source ), dot( target ), forceBuildOptionsoptions ) );
        } else if ( Files.exists( dot( target ) ) ) {
            Files.delete( dot( target ) );
        }
        final Path result = Files.move( sourcetargetoptions );
        return result;
    }
    @Override
    public <V extends FileAttributeView> V getFileAttributeViewfinal Path path,
                                                                 final Class<V> type )
            throws IllegalArgumentException {
        final V value = Files.getFileAttributeView( pathtype );
        if ( value == null && path instanceof AttrHolder ) {
            final AttrHolder holder = ( (AttrHolder) path );
            final V holderView = holder.getAttrView( type );
            if ( holderView == null && AbstractBasicFileAttributeView.class.isAssignableFromtype ) ) {
                return (V) newViewholder, (Class<? extends AbstractBasicFileAttributeView>) type );
            }
            return holderView;
        }
        return value;
    }
    @Override
    public Map<StringObjectreadAttributesfinal Path path,
                                               final String attributes )
            throws UnsupportedOperationException, NoSuchFileException, IllegalArgumentException,
            IOException, SecurityException {
        checkNotNull( "path"path );
        checkNotEmpty"attributes"attributes );
        final Properties original = new Properties( Files.readAttributes( pathattributes ) );
        if ( attributes.equals"*" ) && exists( dot( path ) ) ) {
            boolean isAttrHolder = path instanceof AttrHolder;
            if ( isAttrHolder && ( (AttrHolder) path ).getAttrStorage().getContent().size() > 0 ) {
                return ( (AttrHolder) path ).getAttrStorage().getAllContent();
            }
            final Properties content = new Properties();
            content.load( newInputStream( dot( path ) ) );
            content.putAll( original );
            if ( isAttrHolder ) {
                ( (AttrHolder) path ).getAttrStorage().loadContent( content );
            }
            return content;
        }
        return original;
    }
    @Override
    public synchronized Path setAttributesfinal Path path,
                                            final FileAttribute<?>... attrs )
        checkNotNull( "path"path );
        if ( Files.isDirectory( path ) ) {
            return internalCreateDirectorypathtrueattrs );
        }
        return writepathreadAllBytespath ), Collections.<OpenOption>emptySet(), attrs );
    }
    @Override
    public Object getAttributefinal Path path,
                                final String attribute )
            throws UnsupportedOperationExceptionIllegalArgumentException, IOException, SecurityException {
        checkNotNull( "path"path );
        Object value;
        try {
            value = Files.getAttribute( pathattribute );
        } catch ( UnsupportedOperationException ex ) {
            value = null;
        }
        if ( value == null && path instanceof AttrHolder ) {
            final AttrHolder holder = ( (AttrHolder) path );
            final String[] attr = splitattribute );
            if ( holder.getAttrStorage().getContent().isEmpty() ) {
                loadDotFilepath );
            }
            return holder.getAttrStorage().getAllContent().get( attr[ 1 ] );
        }
        return value;
    }
    @Override
    protected Set<? extends OpenOption> buildOptionsfinal Set<? extends OpenOption> options,
                                                      final OpenOption... others ) {
        return new HashSet<OpenOption>( options ) {{
            addnew DotFileOption() );
            if ( others != null ) {
                for ( final OpenOption other : others ) {
                    addother );
                }
            }
        }};
    }
    protected CopyOption[] buildOptionsfinal CopyOption... options ) {
        final CopyOption[] result = new CopyOption[ options.length + 1 ];
        System.arraycopyoptions, 0, result, 0, options.length );
        resultresult.length - 1 ] = new DotFileOption();
        return result;
    }
    protected CopyOption[] forceBuildOptionsfinal CopyOption[] options ) {
        final CopyOption[] result = new CopyOption[ options.length + 1 ];
        System.arraycopyoptions, 0, result, 0, options.length );
        resultresult.length - 1 ] = REPLACE_EXISTING;
        return result;
    }
    protected boolean isFileSchemefinal Path path ) {
        if ( path == null || path.getFileSystem() == null || path.getFileSystem().provider() == null ) {
            return false;
        }
        return path.getFileSystem().provider().getScheme().equals( "file" );
    }
    protected void loadDotFilefinal Path path ) {
        final Properties content = new Properties();
        content.load( newInputStream( dot( path ) ) );
        if ( path instanceof AttrHolder ) {
            ( (AttrHolder) path ).getAttrStorage().loadContent( content );
        }
    }
    protected <V extends AbstractBasicFileAttributeView> V newViewfinal AttrHolder holder,
                                                                    final Class<V> type ) {
        if ( NeedsPreloadedAttrs.class.isAssignableFromtype ) && holder.getAttrStorage().getContent().size() == 0 ) {
            readAttributes( (Path) holder );
        }
        try {
            final Constructor<V> constructor = (Constructor<V>) type.getConstructors()[ 0 ];
            final V view = constructor.newInstanceholder );
            holder.addAttrView( view );
            return view;
        } catch ( final Exception e ) {
        }
        return null;
    }
    protected synchronized Path internalCreateDirectoryfinal Path dir,
                                                         final boolean skipAlreadyExistsException,
                                                         final FileAttribute<?>... attrs )
            throws IllegalArgumentExceptionUnsupportedOperationException, FileAlreadyExistsException,
            IOException, SecurityException {
        checkNotNull( "dir"dir );
        FileAttribute<?>[] allAttrs = attrs;
        try {
            Files.createDirectory( dirattrs );
        } catch ( final FileAlreadyExistsException ex ) {
            final Properties properties = new Properties();
            if ( exists( dot( dir ) ) ) {
                properties.load( newInputStream( dot( dir ) ) );
            }
            allAttrs = consolidate( propertiesattrs );
            if ( !skipAlreadyExistsException ) {
                throw ex;
            }
        }
        buildDotFile( dirnewOutputStream( dot( dir ) ), allAttrs );
        return dir;
    }
    protected String[] splitfinal String attribute ) {
        final String[] s = new String[ 2 ];
        final int pos = attribute.indexOf':' );
        if ( pos == -1 ) {
            s[ 0 ] = "basic";
            s[ 1 ] = attribute;
        } else {
            s[ 0 ] = attribute.substring( 0, pos );
            s[ 1 ] = ( pos == attribute.length() ) ? "" : attribute.substringpos + 1 );
        }
        return s;
    }
New to GrepCode? Check out our FAQ X