33 import java.util.function.BiConsumer;

    34 import java.util.function.BiFunction;

    35 import java.util.function.Function;

   203     @Override

   220     @Override

   238     @Override

   254     @Override

   281     @Override

   293     @Override

   315     @Override

   326      * If the specified key is not already associated with a value (or is mapped

   327      * to {@code null}) associates it with the given value and returns

   328      * {@code null}, else returns the current value.

   329      *

   330      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   331      * method is called with the string {@code "putProviderProperty."+name},

   332      * where {@code name} is the provider name, to see if it's ok to set this

   333      * provider's property values.

   334      *

   335      * @throws  SecurityException

   336      *          if a security manager exists and its {@link

   337      *          java.lang.SecurityManager#checkSecurityAccess} method

   338      *          denies access to set property values.

   339      */

   340     @Override

   341     public synchronized Object putIfAbsent(Object key, Object value) {

   342         check("putProviderProperty."+name);

   343         if (debug != null) {

   344             debug.println("Set " + name + " provider property [" +

   345                           key + "/" + value +"]");

   346         }

   347         return implPutIfAbsent(key, value);

   348     }

   349 

   350     /**

   366     @Override

   375     /**

   376      * Removes the entry for the specified key only if it is currently

   377      * mapped to the specified value.

   378      *

   379      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   380      * method is called with the string {@code "removeProviderProperty."+name},

   381      * where {@code name} is the provider name, to see if it's ok to remove this

   382      * provider's properties.

   383      *

   384      * @throws  SecurityException

   385      *          if a security manager exists and its {@link

   386      *          java.lang.SecurityManager#checkSecurityAccess} method

   387      *          denies access to remove this provider's properties.

   388      */

   389     @Override

   390     public synchronized boolean remove(Object key, Object value) {

   391         check("removeProviderProperty."+name);

   392         if (debug != null) {

   393             debug.println("Remove " + name + " provider property " + key);

   394         }

   395         return implRemove(key, value);

   396     }

   397 

   398     /**

   399      * Replaces the entry for the specified key only if currently

   400      * mapped to the specified value.

   401      *

   402      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   403      * method is called with the string {@code "putProviderProperty."+name},

   404      * where {@code name} is the provider name, to see if it's ok to set this

   405      * provider's property values.

   406      *

   407      * @throws  SecurityException

   408      *          if a security manager exists and its {@link

   409      *          java.lang.SecurityManager#checkSecurityAccess} method

   410      *          denies access to set property values.

   411      */

   412     @Override

   413     public synchronized boolean replace(Object key, Object oldValue,

   414             Object newValue) {

   415         check("putProviderProperty." + name);

   416 

   417         if (debug != null) {

   418             debug.println("Replace " + name + " provider property " + key);

   419         }

   420         return implReplace(key, oldValue, newValue);

   421     }

   422 

   423     /**

   424      * Replaces the entry for the specified key only if it is

   425      * currently mapped to some value.

   426      *

   427      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   428      * method is called with the string {@code "putProviderProperty."+name},

   429      * where {@code name} is the provider name, to see if it's ok to set this

   430      * provider's property values.

   431      *

   432      * @throws  SecurityException

   433      *          if a security manager exists and its {@link

   434      *          java.lang.SecurityManager#checkSecurityAccess} method

   435      *          denies access to set property values.

   436      */

   437     @Override

   438     public synchronized Object replace(Object key, Object value) {

   439         check("putProviderProperty." + name);

   440 

   441         if (debug != null) {

   442             debug.println("Replace " + name + " provider property " + key);

   443         }

   444         return implReplace(key, value);

   445     }

   446 

   447     /**

   448      * Replaces each entry's value with the result of invoking the given

   449      * function on that entry, in the order entries are returned by an entry

   450      * set iterator, until all entries have been processed or the function

   451      * throws an exception.

   452      *

   453      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   454      * method is called with the string {@code "putProviderProperty."+name},

   455      * where {@code name} is the provider name, to see if it's ok to set this

   456      * provider's property values.

   457      *

   458      * @throws  SecurityException

   459      *          if a security manager exists and its {@link

   460      *          java.lang.SecurityManager#checkSecurityAccess} method

   461      *          denies access to set property values.

   462      */

   463     @Override

   464     public synchronized void replaceAll(BiFunction<? super Object, ? super Object, ? extends Object> function) {

   465         check("putProviderProperty." + name);

   466 

   467         if (debug != null) {

   468             debug.println("ReplaceAll " + name + " provider property ");

   469         }

   470         implReplaceAll(function);

   471     }

   472 

   473     /**

   474      * Attempts to compute a mapping for the specified key and its

   475      * current mapped value (or {@code null} if there is no current

   476      * mapping).

   477      *

   478      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   479      * method is called with the strings {@code "putProviderProperty."+name}

   480      * and {@code "removeProviderProperty."+name}, where {@code name} is the

   481      * provider name, to see if it's ok to set this provider's property values

   482      * and remove this provider's properties.

   483      *

   484      * @throws  SecurityException

   485      *          if a security manager exists and its {@link

   486      *          java.lang.SecurityManager#checkSecurityAccess} method

   487      *          denies access to set property values or remove properties.

   488      */

   489     @Override

   490     public synchronized Object compute(Object key,

   491         BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

   492         check("putProviderProperty." + name);

   493         check("removeProviderProperty" + name);

   494 

   495         if (debug != null) {

   496             debug.println("Compute " + name + " provider property " + key);

   497         }

   498         return implCompute(key, remappingFunction);

   499     }

   500 

   501     /**

   502      * If the specified key is not already associated with a value (or

   503      * is mapped to {@code null}), attempts to compute its value using

   504      * the given mapping function and enters it into this map unless

   505      * {@code null}.

   506      *

   507      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   508      * method is called with the strings {@code "putProviderProperty."+name}

   509      * and {@code "removeProviderProperty."+name}, where {@code name} is the

   510      * provider name, to see if it's ok to set this provider's property values

   511      * and remove this provider's properties.

   512      *

   513      * @throws  SecurityException

   514      *          if a security manager exists and its {@link

   515      *          java.lang.SecurityManager#checkSecurityAccess} method

   516      *          denies access to set property values and remove properties.

   517      */

   518     @Override

   519     public synchronized Object computeIfAbsent(Object key, Function<? super Object, ? extends Object> mappingFunction) {

   520         check("putProviderProperty." + name);

   521         check("removeProviderProperty" + name);

   522 

   523         if (debug != null) {

   524             debug.println("ComputeIfAbsent " + name + " provider property " +

   525                     key);

   526         }

   527         return implComputeIfAbsent(key, mappingFunction);

   528     }

   529 

   530     /**

   531      * If the value for the specified key is present and non-null, attempts to

   532      * compute a new mapping given the key and its current mapped value.

   533      *

   534      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   535      * method is called with the strings {@code "putProviderProperty."+name}

   536      * and {@code "removeProviderProperty."+name}, where {@code name} is the

   537      * provider name, to see if it's ok to set this provider's property values

   538      * and remove this provider's properties.

   539      *

   540      * @throws  SecurityException

   541      *          if a security manager exists and its {@link

   542      *          java.lang.SecurityManager#checkSecurityAccess} method

   543      *          denies access to set property values or remove properties.

   544      */

   545     @Override

   546     public synchronized Object computeIfPresent(Object key, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

   547         check("putProviderProperty." + name);

   548         check("removeProviderProperty" + name);

   549 

   550         if (debug != null) {

   551             debug.println("ComputeIfPresent " + name + " provider property " +

   552                     key);

   553         }

   554         return implComputeIfPresent(key, remappingFunction);

   555     }

   556 

   557     /**

   558      * If the specified key is not already associated with a value or is

   559      * associated with null, associates it with the given value. Otherwise,

   560      * replaces the value with the results of the given remapping function,

   561      * or removes if the result is null. This method may be of use when

   562      * combining multiple mapped values for a key.

   563      *

   564      * <p>If a security manager is enabled, its {@code checkSecurityAccess}

   565      * method is called with the strings {@code "putProviderProperty."+name}

   566      * and {@code "removeProviderProperty."+name}, where {@code name} is the

   567      * provider name, to see if it's ok to set this provider's property values

   568      * and remove this provider's properties.

   569      *

   570      * @throws  SecurityException

   571      *          if a security manager exists and its {@link

   572      *          java.lang.SecurityManager#checkSecurityAccess} method

   573      *          denies access to set property values or remove properties.

   574      */

   575     @Override

   576     public synchronized Object merge(Object key, Object value,  BiFunction<? super Object, ? super Object, ? extends Object>  remappingFunction) {

   577         check("putProviderProperty." + name);

   578         check("removeProviderProperty" + name);

   579 

   580         if (debug != null) {

   581             debug.println("Merge " + name + " provider property " + key);

   582         }

   583         return implMerge(key, value, remappingFunction);

   584     }

   585 

   587     @Override

   593     @Override

   594     public synchronized Object getOrDefault(Object key, Object defaultValue) {

   595         checkInitialized();

   596         return super.getOrDefault(key, defaultValue);

   597     }

   598 

   599     @Override

   600     public synchronized void forEach(BiConsumer<? super Object, ? super Object> action) {

   601         checkInitialized();

   602         super.forEach(action);

   603     }

   604 

   606     @Override

   613     @Override

   683     private boolean checkLegacy(Object key) {

   684         String keyString = (String)key;

   685         if (keyString.startsWith("Provider.")) {

   686             return false;

   687         }

   688 

   689         legacyChanged = true;

   690         if (legacyStrings == null) {

   691             legacyStrings = new LinkedHashMap<String,String>();

   692         }

   693         return true;

   694     }

   695 

   715     }

   716 

   717     private boolean implRemove(Object key, Object value) {

   718         if (key instanceof String && value instanceof String) {

   719             if (!checkLegacy(key)) {

   720                 return false;

   721             }

   722             legacyStrings.remove((String)key, value);

   723         }

   724         return super.remove(key, value);

   725     }

   726 

   727     private boolean implReplace(Object key, Object oldValue, Object newValue) {

   728         if ((key instanceof String) && (oldValue instanceof String) &&

   729                 (newValue instanceof String)) {

   730             if (!checkLegacy(key)) {

   731                 return false;

   732             }

   733             legacyStrings.replace((String)key, (String)oldValue,

   734                     (String)newValue);

   735         }

   736         return super.replace(key, oldValue, newValue);

   737     }

   738 

   739     private Object implReplace(Object key, Object value) {

   740         if ((key instanceof String) && (value instanceof String)) {

   741             if (!checkLegacy(key)) {

   742                 return null;

   743             }

   744             legacyStrings.replace((String)key, (String)value);

   745         }

   746         return super.replace(key, value);

   747     }

   748 

   749     private void implReplaceAll(BiFunction<? super Object, ? super Object, ? extends Object> function) {

   750         legacyChanged = true;

   751         if (legacyStrings == null) {

   752             legacyStrings = new LinkedHashMap<String,String>();

   753         } else {

   754             legacyStrings.replaceAll((BiFunction<? super String, ? super String, ? extends String>) function);

   755         }

   756         super.replaceAll(function);

   757     }

   758 

   759 

   760     private Object implMerge(Object key, Object value, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

   761         if ((key instanceof String) && (value instanceof String)) {

   762             if (!checkLegacy(key)) {

   763                 return null;

   764             }

   765             legacyStrings.merge((String)key, (String)value,

   766                     (BiFunction<? super String, ? super String, ? extends String>) remappingFunction);

   767         }

   768         return super.merge(key, value, remappingFunction);

   769     }

   770 

   771     private Object implCompute(Object key, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

   772         if (key instanceof String) {

   773             if (!checkLegacy(key)) {

   774                 return null;

   775             }

   776             legacyStrings.computeIfAbsent((String) key,

   777                     (Function<? super String, ? extends String>) remappingFunction);

   778         }

   779         return super.compute(key, remappingFunction);

   780     }

   781 

   782     private Object implComputeIfAbsent(Object key, Function<? super Object, ? extends Object> mappingFunction) {

   783         if (key instanceof String) {

   784             if (!checkLegacy(key)) {

   785                 return null;

   786             }

   787             legacyStrings.computeIfAbsent((String) key,

   788                     (Function<? super String, ? extends String>) mappingFunction);

   789         }

   790         return super.computeIfAbsent(key, mappingFunction);

   791     }

   792 

   793     private Object implComputeIfPresent(Object key, BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {

   794         if (key instanceof String) {

   795             if (!checkLegacy(key)) {

   796                 return null;

   797             }

   798             legacyStrings.computeIfPresent((String) key,

   799                     (BiFunction<? super String, ? super String, ? extends String>) remappingFunction);

   800         }

   801         return super.computeIfPresent(key, remappingFunction);

   812     }

   813 

   814     private Object implPutIfAbsent(Object key, Object value) {

   815         if ((key instanceof String) && (value instanceof String)) {

   816             if (!checkLegacy(key)) {

   817                 return null;

   818             }

   819             legacyStrings.putIfAbsent((String)key, (String)value);

   820         }

   821         return super.putIfAbsent(key, value);