How to use

Properties

in

org.kie.commons.java.nio.base

public void load( final InputStream in ) {
  load( in, true );
}

public Properties( final Map<String, Object> original ) {
  putAll( original );
}

@Override
public void loadContent( final Properties properties ) {
  content.clear();
  for ( final Map.Entry<String, Object> attr : properties.entrySet() ) {
    content.put( attr.getKey(), attr.getValue() );
  }
}

protected void loadDotFile( final Path path ) {
  final Properties content = new Properties();
  content.load( newInputStream( dot( path ) ) );
  if ( path instanceof AttrHolder ) {
    ( (AttrHolder) path ).getAttrStorage().loadContent( content );
  }
}

@Override
public Map<String, Object> readAttributes( final Path path,
                      final String attributes )
    throws UnsupportedOperationException, NoSuchFileException, IllegalArgumentException,
    IOException, SecurityException {
  checkNotNull( "path", path );
  checkNotEmpty( "attributes", attributes );
  final Properties original = new Properties( Files.readAttributes( path, attributes ) );
  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;
}

public void load( final InputStream in,
         boolean closeOnFinish ) {
  final XStream xstream = new XStream();
  final Properties temp = new Properties();
  try {
    xstream.fromXML( in, temp );
  } catch ( final XStreamException ex ) {
    if ( !ex.getMessage().equals( " : input contained no data" ) ) {
      throw ex;
    }
  }
  for ( final Map.Entry<String, Object> entry : temp.entrySet() ) {
    if ( entry.getValue() != null ) {
      put( entry.getKey(), entry.getValue() );
    }
  }
  temp.clear();
  if ( closeOnFinish ) {
    try {
      in.close();
    } catch ( IOException e ) {
    }
  }
}

public static void buildDotFile( final Path path,
                 final OutputStream out,
                 final FileAttribute<?>... attrs ) {
  if ( attrs != null && attrs.length > 0 ) {
    final Properties properties = new Properties();
    for ( final FileAttribute<?> attr : attrs ) {
      if ( attr.value() instanceof Serializable ) {
        properties.put( attr.name(), attr.value() );
      }
    }
    try {
      properties.store( out );
    } catch ( final Exception e ) {
      throw new IOException( e );
    }
    if ( path instanceof AttrHolder ) {
      ( (AttrHolder) path ).getAttrStorage().loadContent( properties );
    }
  } else {
    path.getFileSystem().provider().deleteIfExists( dot( path ) );
  }
}

  private synchronized Properties buildProperties( boolean includesNonSerializable ) {
    final Properties properties = new Properties( content );

    for ( final Map.Entry<String, AttributeView> view : viewsNameIndex.entrySet() ) {
      if ( includesNonSerializable ||
          view.getValue() instanceof ExtendedAttributeView && ( (ExtendedAttributeView) view.getValue() ).isSerializable() ) {
        final ExtendedAttributeView extendedView = (ExtendedAttributeView) view.getValue();
        for ( final Map.Entry<String, Object> attr : extendedView.readAllAttributes().entrySet() ) {
          properties.put( attr.getKey(), attr.getValue() );
        }
      }
    }

    return properties;
  }
}

public void store( final OutputStream out ) {
  store( out, true );
}

public Object put( final String key,
          final Object value ) {
  if ( value == null ) {
    return remove( key );
  }
  return super.put( key, value );
}

@Override
public void clear() {
  viewsNameIndex.clear();
  viewsTypeIndex.clear();
  content.clear();
}

protected synchronized Path internalCreateDirectory( final Path dir,
                           final boolean skipAlreadyExistsException,
                           final FileAttribute<?>... attrs )
    throws IllegalArgumentException, UnsupportedOperationException, FileAlreadyExistsException,
    IOException, SecurityException {
  checkNotNull( "dir", dir );
  FileAttribute<?>[] allAttrs = attrs;
  try {
    Files.createDirectory( dir, attrs );
  } catch ( final FileAlreadyExistsException ex ) {
    final Properties properties = new Properties();
    if ( exists( dot( dir ) ) ) {
      properties.load( newInputStream( dot( dir ) ) );
    }
    allAttrs = consolidate( properties, attrs );
    if ( !skipAlreadyExistsException ) {
      throw ex;
    }
  }
  buildDotFile( dir, newOutputStream( dot( dir ) ), allAttrs );
  return dir;
}

@Override
public synchronized SeekableByteChannel newByteChannel( final Path path,
                            final Set<? extends OpenOption> options,
                            final FileAttribute<?>... attrs )
    throws IllegalArgumentException, UnsupportedOperationException,
    FileAlreadyExistsException, IOException, SecurityException {
  checkNotNull( "path", path );
  final Properties properties = new Properties();
  if ( exists( dot( path ) ) ) {
    properties.load( newInputStream( dot( path ) ) );
  }
  final FileAttribute<?>[] allAttrs = consolidate( properties, attrs );
  final SeekableByteChannel result = Files.newByteChannel( path, buildOptions( options ), allAttrs );
  if ( isFileScheme( path ) ) {
    buildDotFile( path, newOutputStream( dot( path ) ), allAttrs );
  }
  return result;
}