jdk/src/share/classes/sun/nio/fs/AbstractBasicFileAttributeView.java
changeset 3065 452aaa2899fc
parent 2057 3acf8e5e2ca0
child 5506 202f599c92aa
equal deleted inserted replaced
3063:a3fd491f7754 3065:452aaa2899fc
    24  */
    24  */
    25 
    25 
    26 package sun.nio.fs;
    26 package sun.nio.fs;
    27 
    27 
    28 import java.nio.file.attribute.*;
    28 import java.nio.file.attribute.*;
       
    29 import java.util.*;
    29 import java.io.IOException;
    30 import java.io.IOException;
    30 import java.util.*;
       
    31 import java.util.concurrent.TimeUnit;
       
    32 
    31 
    33 /**
    32 /**
    34  * Base implementation of BasicFileAttributeView
    33  * Base implementation of BasicFileAttributeView
    35  */
    34  */
    36 
    35 
    37 abstract class AbstractBasicFileAttributeView
    36 abstract class AbstractBasicFileAttributeView
    38     implements BasicFileAttributeView
    37     implements BasicFileAttributeView, DynamicFileAttributeView
    39 {
    38 {
    40     private static final String SIZE_NAME = "size";
    39     private static final String SIZE_NAME = "size";
    41     private static final String CREATION_TIME_NAME = "creationTime";
    40     private static final String CREATION_TIME_NAME = "creationTime";
    42     private static final String LAST_ACCESS_TIME_NAME = "lastAccessTime";
    41     private static final String LAST_ACCESS_TIME_NAME = "lastAccessTime";
    43     private static final String LAST_MODIFIED_TIME_NAME = "lastModifiedTime";
    42     private static final String LAST_MODIFIED_TIME_NAME = "lastModifiedTime";
    44     private static final String RESOLUTION_NAME = "resolution";
       
    45     private static final String FILE_KEY_NAME = "fileKey";
    43     private static final String FILE_KEY_NAME = "fileKey";
    46     private static final String LINK_COUNT_NAME = "linkCount";
       
    47     private static final String IS_DIRECTORY_NAME = "isDirectory";
    44     private static final String IS_DIRECTORY_NAME = "isDirectory";
    48     private static final String IS_REGULAR_FILE_NAME = "isRegularFile";
    45     private static final String IS_REGULAR_FILE_NAME = "isRegularFile";
    49     private static final String IS_SYMBOLIC_LINK_NAME = "isSymbolicLink";
    46     private static final String IS_SYMBOLIC_LINK_NAME = "isSymbolicLink";
    50     private static final String IS_OTHER_NAME = "isOther";
    47     private static final String IS_OTHER_NAME = "isOther";
    51 
    48 
    65             return attrs.creationTime();
    62             return attrs.creationTime();
    66         if (attribute.equals(LAST_ACCESS_TIME_NAME))
    63         if (attribute.equals(LAST_ACCESS_TIME_NAME))
    67             return attrs.lastAccessTime();
    64             return attrs.lastAccessTime();
    68         if (attribute.equals(LAST_MODIFIED_TIME_NAME))
    65         if (attribute.equals(LAST_MODIFIED_TIME_NAME))
    69             return attrs.lastModifiedTime();
    66             return attrs.lastModifiedTime();
    70         if (attribute.equals(RESOLUTION_NAME))
       
    71             return attrs.resolution();
       
    72         if (attribute.equals(FILE_KEY_NAME))
    67         if (attribute.equals(FILE_KEY_NAME))
    73             return attrs.fileKey();
    68             return attrs.fileKey();
    74         if (attribute.equals(LINK_COUNT_NAME))
       
    75             return attrs.linkCount();
       
    76         if (attribute.equals(IS_DIRECTORY_NAME))
    69         if (attribute.equals(IS_DIRECTORY_NAME))
    77             return attrs.isDirectory();
    70             return attrs.isDirectory();
    78         if (attribute.equals(IS_REGULAR_FILE_NAME))
    71         if (attribute.equals(IS_REGULAR_FILE_NAME))
    79             return attrs.isRegularFile();
    72             return attrs.isRegularFile();
    80         if (attribute.equals(IS_SYMBOLIC_LINK_NAME))
    73         if (attribute.equals(IS_SYMBOLIC_LINK_NAME))
    82         if (attribute.equals(IS_OTHER_NAME))
    75         if (attribute.equals(IS_OTHER_NAME))
    83             return attrs.isOther();
    76             return attrs.isOther();
    84         return null;
    77         return null;
    85     }
    78     }
    86 
    79 
    87     private Long toTimeValue(Object value) {
       
    88         if (value == null)
       
    89             throw new NullPointerException();
       
    90         Long time = (Long)value;
       
    91         if (time < 0L && time != -1L)
       
    92             throw new IllegalArgumentException("time value cannot be negative");
       
    93         return time;
       
    94     }
       
    95 
       
    96     @Override
    80     @Override
    97     public void setAttribute(String attribute, Object value)
    81     public void setAttribute(String attribute, Object value)
    98         throws IOException
    82         throws IOException
    99     {
    83     {
   100         if (attribute.equals(LAST_MODIFIED_TIME_NAME)) {
    84         if (attribute.equals(LAST_MODIFIED_TIME_NAME)) {
   101             setTimes(toTimeValue(value), null, null, TimeUnit.MILLISECONDS);
    85             setTimes((FileTime)value, null, null);
   102             return;
    86             return;
   103         }
    87         }
   104         if (attribute.equals(LAST_ACCESS_TIME_NAME)) {
    88         if (attribute.equals(LAST_ACCESS_TIME_NAME)) {
   105             setTimes(null, toTimeValue(value), null, TimeUnit.MILLISECONDS);
    89             setTimes(null, (FileTime)value, null);
   106             return;
    90             return;
   107         }
    91         }
   108         if (attribute.equals(CREATION_TIME_NAME)) {
    92         if (attribute.equals(CREATION_TIME_NAME)) {
   109             setTimes(null, null, toTimeValue(value), TimeUnit.MILLISECONDS);
    93             setTimes(null, null, (FileTime)value);
   110             return;
    94             return;
   111         }
    95         }
   112         throw new UnsupportedOperationException("'" + attribute +
    96         throw new UnsupportedOperationException("'" + attribute +
   113             "' is unknown or read-only attribute");
    97             "' is unknown or read-only attribute");
   114     }
    98     }
   115 
    99 
   116     /**
   100     /**
   117      *
   101      * Used to build a map of attribute name/values.
   118      */
   102      */
   119     static class AttributesBuilder {
   103     static class AttributesBuilder {
   120         private Set<String> set = new HashSet<String>();
   104         private Set<String> set = new HashSet<String>();
   121         private Map<String,Object> map = new HashMap<String,Object>();
   105         private Map<String,Object> map = new HashMap<String,Object>();
   122         private boolean copyAll;
   106         private boolean copyAll;
   123 
   107 
   124         private AttributesBuilder(String first, String[] rest) {
   108         private AttributesBuilder(String[] attributes) {
   125             if (first.equals("*")) {
   109             for (String attribute: attributes) {
   126                 copyAll = true;
   110                 if (attribute.equals("*")) {
   127             } else {
   111                     copyAll = true;
   128                 set.add(first);
   112                 } else {
   129                 // copy names into the given Set bailing out if "*" is found
       
   130                 for (String attribute: rest) {
       
   131                     if (attribute.equals("*")) {
       
   132                         copyAll = true;
       
   133                         break;
       
   134                     }
       
   135                     set.add(attribute);
   113                     set.add(attribute);
   136                 }
   114                 }
   137             }
   115             }
   138         }
   116         }
   139 
   117 
   140         /**
   118         /**
   141          * Creates builder to build up a map of the matching attributes
   119          * Creates builder to build up a map of the matching attributes
   142          */
   120          */
   143         static AttributesBuilder create(String first, String[] rest) {
   121         static AttributesBuilder create(String[] attributes) {
   144             return new AttributesBuilder(first, rest);
   122             return new AttributesBuilder(attributes);
   145         }
   123         }
   146 
   124 
   147         /**
   125         /**
   148          * Returns true if the attribute should be returned in the map
   126          * Returns true if the attribute should be returned in the map
   149          */
   127          */
   179             builder.add(CREATION_TIME_NAME, attrs.creationTime());
   157             builder.add(CREATION_TIME_NAME, attrs.creationTime());
   180         if (builder.match(LAST_ACCESS_TIME_NAME))
   158         if (builder.match(LAST_ACCESS_TIME_NAME))
   181             builder.add(LAST_ACCESS_TIME_NAME, attrs.lastAccessTime());
   159             builder.add(LAST_ACCESS_TIME_NAME, attrs.lastAccessTime());
   182         if (builder.match(LAST_MODIFIED_TIME_NAME))
   160         if (builder.match(LAST_MODIFIED_TIME_NAME))
   183             builder.add(LAST_MODIFIED_TIME_NAME, attrs.lastModifiedTime());
   161             builder.add(LAST_MODIFIED_TIME_NAME, attrs.lastModifiedTime());
   184         if (builder.match(RESOLUTION_NAME))
       
   185             builder.add(RESOLUTION_NAME, attrs.resolution());
       
   186         if (builder.match(FILE_KEY_NAME))
   162         if (builder.match(FILE_KEY_NAME))
   187             builder.add(FILE_KEY_NAME, attrs.fileKey());
   163             builder.add(FILE_KEY_NAME, attrs.fileKey());
   188         if (builder.match(LINK_COUNT_NAME))
       
   189             builder.add(LINK_COUNT_NAME, attrs.linkCount());
       
   190         if (builder.match(IS_DIRECTORY_NAME))
   164         if (builder.match(IS_DIRECTORY_NAME))
   191             builder.add(IS_DIRECTORY_NAME, attrs.isDirectory());
   165             builder.add(IS_DIRECTORY_NAME, attrs.isDirectory());
   192         if (builder.match(IS_REGULAR_FILE_NAME))
   166         if (builder.match(IS_REGULAR_FILE_NAME))
   193             builder.add(IS_REGULAR_FILE_NAME, attrs.isRegularFile());
   167             builder.add(IS_REGULAR_FILE_NAME, attrs.isRegularFile());
   194         if (builder.match(IS_SYMBOLIC_LINK_NAME))
   168         if (builder.match(IS_SYMBOLIC_LINK_NAME))
   196         if (builder.match(IS_OTHER_NAME))
   170         if (builder.match(IS_OTHER_NAME))
   197             builder.add(IS_OTHER_NAME, attrs.isOther());
   171             builder.add(IS_OTHER_NAME, attrs.isOther());
   198     }
   172     }
   199 
   173 
   200     @Override
   174     @Override
   201     public Map<String,?> readAttributes(String first, String[] rest)
   175     public Map<String,?> readAttributes(String[] attributes) throws IOException {
   202         throws IOException
   176         AttributesBuilder builder = AttributesBuilder.create(attributes);
   203     {
       
   204         AttributesBuilder builder = AttributesBuilder.create(first, rest);
       
   205         addBasicAttributesToBuilder(readAttributes(), builder);
   177         addBasicAttributesToBuilder(readAttributes(), builder);
   206         return builder.unmodifiableMap();
   178         return builder.unmodifiableMap();
   207     }
   179     }
   208 }
   180 }