Utilities.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */



  23. package org.openspcoop2.utils;


  26. import java.io.ByteArrayInputStream;
  27. import java.io.ByteArrayOutputStream;
  28. import java.io.File;
  29. import java.io.IOException;
  30. import java.io.InputStream;
  31. import java.io.InputStreamReader;
  32. import java.io.OutputStream;
  33. import java.io.SequenceInputStream;
  34. import java.io.StringWriter;
  35. import java.lang.reflect.Field;
  36. import java.net.URL;
  37. import java.nio.file.Files;
  38. import java.nio.file.Path;
  39. import java.nio.file.attribute.FileAttribute;
  40. import java.nio.file.attribute.PosixFilePermission;
  41. import java.nio.file.attribute.PosixFilePermissions;
  42. import java.text.MessageFormat;
  43. import java.util.ArrayList;
  44. import java.util.HashMap;
  45. import java.util.Iterator;
  46. import java.util.List;
  47. import java.util.Map;
  48. import java.util.Properties;
  49. import java.util.Set;
  50. import java.util.concurrent.Callable;
  51. import java.util.concurrent.ConcurrentHashMap;
  52. import java.util.concurrent.ConcurrentMap;
  53. import java.util.concurrent.ExecutionException;
  54. import java.util.concurrent.ExecutorService;
  55. import java.util.concurrent.Executors;
  56. import java.util.concurrent.Future;
  57. import java.util.concurrent.TimeUnit;
  58. import java.util.concurrent.TimeoutException;

  60. import org.apache.commons.lang.StringUtils;
  61. import org.apache.commons.lang.SystemUtils;
  62. import org.apache.commons.lang.WordUtils;
  63. import org.slf4j.Logger;


  66. /**
  67.  * Libreria contenente metodi utili generale.
  68.  *
  69.  *
  70.  * @author Poli Andrea (apoli@link.it)
  71.  * @author $Author$
  72.  * @version $Rev$, $Date$
  73.  */

  75. public class Utilities {

  77.     private Utilities() {}
  78.     
  79.     
  80.     // ** Thread Sleep **
  81.     public static void sleep(long ms) {
  82.         try {
  83.             Thread.sleep(ms);
  84.         }catch(InterruptedException t) {
  85.             // ignore
  86.             Thread.currentThread().interrupt();
  87.         }
  88.     }
  89.     
  90.     @SuppressWarnings("unchecked")
  91.     public static <T> T execute(int secondsTimeout, Callable<?> callable) throws TimeoutException, UtilsException {
  92.         ExecutorService executor = Executors.newSingleThreadExecutor();
  93.         try {
  94.             Future<?> future = executor.submit(callable);
  95.             return (T) future.get(secondsTimeout, TimeUnit.SECONDS); //timeout is in 2 seconds
  96.         } catch (TimeoutException e) {
  97.             throw e;
  98.         } catch (InterruptedException e) {
  99.             Thread.currentThread().interrupt();
  100.             throw new UtilsException(e.getMessage(),e);
  101.         } catch (ExecutionException e) {
  102.             throw new UtilsException(e.getMessage(),e);
  103.         }finally {
  104.             executor.shutdownNow();
  105.         }
  106.     }
  107.     
  108.     
  109.     
  110.     
  111.     // Class.newInstance() is deprecated in Java 1++
  112.     @SuppressWarnings("unchecked")
  113.     public static <T> T newInstance(String className) throws UtilsException {
  114.         if(className!=null && !StringUtils.isEmpty(className)) {
  115.             try {
  116.                 return  (T) newInstance(Class.forName(className));
  117.             }catch(Exception e) {
  118.                 throw new UtilsException(e.getMessage(), e);
  119.             }
  120.         }
  121.         return null;
  122.     }
  123.     public static <T> T newInstance(Class<T> classType) throws UtilsException {
  124.         if(classType!=null) {
  125.             try {
  126.                 return  classType.getConstructor().newInstance();
  127.             }catch(Exception e) {
  128.                 throw new UtilsException(e.getMessage(), e);
  129.             }
  130.         }
  131.         return null;
  132.     }
  133.     
  134.     public static <T> T newInstanceThrowInstantiationException(String className) throws InstantiationException {
  135.         try {
  136.             return newInstance(className);
  137.         }catch(Exception e) {
  138.             throw new InstantiationException(e.getMessage());
  139.         }
  140.     }
  141.     public static <T> T newInstanceThrowInstantiationException(Class<T> classType) throws InstantiationException {
  142.         try {
  143.             return newInstance(classType);
  144.         }catch(Exception e) {
  145.             throw new InstantiationException(e.getMessage());
  146.         }
  147.     }
  148.     
  149.     
  150.     public static boolean equalsClass(Object o1, Object o2) {
  151.         if(o1==null || o2==null) {
  152.             return false;
  153.         }
  154.         //return o1.getClass().getName().equals(o2.getClass().getName()); sonar java:S1872
  155.         return o1.getClass().equals(o2.getClass());
  156.     }
  157.     


  160.     /** ArrayBuffer utilizzato per la lettura */
  161.     public static final int DIMENSIONE_BUFFER = 65536;
  162.     
  163.     
  164.     /** String with charset Processing */
  165.     public static String getAsString(URL url,String charsetName) throws UtilsException{
  166.         return getAsString(url, charsetName, true);
  167.     }
  168.     public static String getAsString(URL url,String charsetName,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  169.         try{
  170.             String content = null;
  171.             try (InputStream openStream = url.openStream();){
  172.                 content = Utilities.getAsString(openStream,charsetName,throwExceptionInputStreamEmpty);
  173.             }
  174.             return content;
  175.         }
  176.         catch (UtilsException e) {
  177.             throw e;
  178.         }
  179.         catch (java.lang.Exception e) {
  180.             throw new UtilsException("Utilities.getAsString error "+e.getMessage(),e);
  181.         }
  182.     }
  183.     public static String getAsString(InputStream is,String charsetName) throws UtilsException{
  184.         return getAsString(is,charsetName,true);
  185.     }
  186.     public static String getAsString(InputStream is,String charsetName,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  187.         try{
  188.             StringBuilder sb = Utilities.getAsInputStreamReader(is,charsetName,throwExceptionInputStreamEmpty);
  189.             if(sb==null){
  190.                 /** se si entra qua throwExceptionInputStreamEmpty e' per forza false
  191.                 if(throwExceptionInputStreamEmpty){
  192.                     throw new UtilsException("getAsInputStreamReader is null");
  193.                 }
  194.                 else{*/
  195.                 return null;
  196.             }
  197.             return sb.toString();           
  198.         }
  199.         catch (UtilsException e) {
  200.             throw e;
  201.         }
  202.         catch (java.lang.Exception e) {
  203.             throw new UtilsException("Utilities.getAsString error "+e.getMessage(),e);
  204.         }
  205.     }
  206.     public static StringBuilder getAsInputStreamReader(InputStream isParam,String charsetName) throws UtilsException{
  207.         return getAsInputStreamReader(isParam, charsetName, true);
  208.     }
  209.     public static StringBuilder getAsInputStreamReader(InputStream isParam,String charsetName,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  210.         
  211.         InputStream is = null;
  212.         try{
  213.             if(isParam==null){
  214.                 if(throwExceptionInputStreamEmpty){
  215.                     throw new UtilsException("InputStream is null");
  216.                 }
  217.                 else{
  218.                     return null;
  219.                 }
  220.             }
  221.             
  222.             is = normalizeStream(isParam, throwExceptionInputStreamEmpty);
  223.             if(is==null) {
  224.                 // nel caso serva l'eccezione, viene lanciata nel normalizeStream.
  225.                 // NOTA: al metodo normalizeStream viene passato per forza un oggetto non null, altrimenti si entra nel controllo precedente
  226.                 return null;
  227.             }
  228.         } catch (Exception e) {
  229.             throw parseException(e, "getAsInputStreamReader");
  230.         } 
  231.         
  232.         try (InputStreamReader isr = new InputStreamReader(is, charsetName);){
  233.             
  234.             StringWriter writer = new StringWriter();
  235.             CopyCharStream.copy(isr, writer);
  236.             return new StringBuilder(writer.toString());
  237.             
  238.         } catch (Exception e) {
  239.             throw parseException(e, "getAsInputStreamReader");
  240.         } 
  241.     }
  242.     private static UtilsException parseException(Exception e, String method) {
  243.         if(e instanceof java.io.IOException){
  244.             if(!isEmpytMessageException(e)){
  245.                 return new UtilsException(e.getMessage(),e);
  246.             }
  247.         }
  248.         else if(existsInnerException(e, java.io.IOException.class)){
  249.             Throwable tInternal = getInnerException(e, java.io.IOException.class);
  250.             if(!isEmpytMessageException(tInternal)){
  251.                 return new UtilsException(tInternal.getMessage(),e);
  252.             }
  253.         }

  255.         Throwable tInternal = getInnerNotEmptyMessageException(e);
  256.         if(tInternal!=null){
  257.             return new UtilsException(tInternal.getMessage(),e);
  258.         }
  259.         else{
  260.             return new UtilsException("Utilities."+method+" error",e);
  261.         }
  262.     }
  263.     
  264.     
  265.     /** RawBinary Processing */
  266.     public static byte[] getAsByteArray(URL url) throws UtilsException{
  267.         return getAsByteArray(url, true);
  268.     }
  269.     public static byte[] getAsByteArray(URL url,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  270.         try{
  271.             byte[] content = null;
  272.             try (InputStream openStream = url.openStream();){
  273.                 content = Utilities.getAsByteArray(openStream,throwExceptionInputStreamEmpty);
  274.             }
  275.             return content;
  276.         }
  277.         catch (UtilsException e) {
  278.             throw e;
  279.         }
  280.         catch (java.lang.Exception e) {
  281.             throw new UtilsException("Utilities.readBytes error "+e.getMessage(),e);
  282.         }
  283.     }
  284.     public static byte[] getAsByteArray(InputStream is) throws UtilsException{
  285.         return getAsByteArray(is,true);
  286.     }
  287.     public static byte[] getAsByteArray(InputStream is,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  288.         try{
  289.             byte[] returnNull = null;
  290.             ByteArrayOutputStream bout = Utilities.getAsByteArrayOuputStream(is,throwExceptionInputStreamEmpty);
  291.             if(bout!=null) {
  292.                 return bout.toByteArray();
  293.             }
  294.             else {
  295.                 return returnNull; // puo' succedere solo se throwExceptionInputStreamEmpty e' false
  296.             }
  297.         }
  298.         catch (UtilsException e) {
  299.             throw e;
  300.         }
  301.         catch (java.lang.Exception e) {
  302.             throw new UtilsException("Utilities.readBytes error "+e.getMessage(),e);
  303.         }
  304.     }
  305.     public static ByteArrayOutputStream getAsByteArrayOuputStream(InputStream isParam) throws UtilsException{
  306.         return getAsByteArrayOuputStream(isParam, true);
  307.     }
  308.     public static void writeAsByteArrayOuputStream(ByteArrayOutputStream bout, InputStream isParam) throws UtilsException{
  309.         writeAsByteArrayOuputStream(bout, isParam, true);
  310.     }
  311.     public static ByteArrayOutputStream getAsByteArrayOuputStream(InputStream isParam,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  312.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  313.         writeAsByteArrayOuputStream(bout, isParam, throwExceptionInputStreamEmpty);
  314.         if(bout.size()>0) {
  315.             return bout;
  316.         }else {
  317.             return null;
  318.         }
  319.     }
  320.     public static void writeAsByteArrayOuputStream(OutputStream bout, InputStream isParam,boolean throwExceptionInputStreamEmpty) throws UtilsException{
  321.         try{
  322.             if(isParam==null){
  323.                 if(throwExceptionInputStreamEmpty){
  324.                     throw new UtilsException("InputStream is null");
  325.                 }
  326.                 else{
  327.                     return;
  328.                 }
  329.             }
  330.             
  331.             InputStream is = normalizeStream(isParam, throwExceptionInputStreamEmpty);
  332.             if(is==null) {
  333.                 // nel caso serva l'eccezione, viene lanciata nel normalizeStream.
  334.                 // NOTA: al metodo normalizeStream viene passato per forza un oggetto non null, altrimenti si entra nel controllo precedente
  335.                 return;
  336.             }           
  337.             
  338.             CopyStream.copy(CopyStreamMethod.AUTO, is, bout);
  339.             
  340.         } catch (java.lang.Exception e) {
  341.             throw parseException(e, "writeAsByteArrayOuputStream");
  342.         }
  343.     }


  346.     public static InputStream normalizeStream(InputStream is, boolean throwExceptionInputStreamEmpty) throws UtilsException {
  347.         try {
  348.             if(is!=null){
  349.                 byte[] buffer = new byte[2]; // UTF-16
  350.                 int letti = is.read(buffer);
  351.                 if( letti <=0 ) {
  352.                     if(throwExceptionInputStreamEmpty){
  353.                         throw new UtilsException("InputStream is empty (class:"+is.getClass().getName()+")");
  354.                     }
  355.                     else{
  356.                         return null;
  357.                     }
  358.                 } else {
  359.                     // Metodo alternativo: java.io.PushbackInputStream
  360.                     byte [] b = null;
  361.                     if(letti==2) {
  362.                         b = buffer;
  363.                     }
  364.                     else {
  365.                         b = new byte[1]; // e' per forza 1
  366.                         b[0] = buffer[0];
  367.                     }
  368.                     return new SequenceInputStream(new ByteArrayInputStream(b),is);
  369.                 }
  370.             }
  371.             return is; // null
  372.         }catch(Exception e){
  373.             throw new UtilsException(e.getMessage(),e);
  374.         }
  375.     }
  376.     
  377.     
  378.     
  379.     /** Copy Stream */
  380.     
  381.     public static void copy(InputStream is,OutputStream os) throws UtilsException{
  382.         try{
  383.             CopyStream.copy(CopyStreamMethod.AUTO, is, os);
  384.         }catch(Exception e){
  385.             throw new UtilsException(e.getMessage(),e);
  386.         }
  387.     }
  388.     
  389.     


  392.     /** Properties */
  393.     
  394.     public static java.util.Properties getAsProperties(InputStream is) throws UtilsException{
  395.         try{
  396.             if(is==null){
  397.                 throw new UtilsException("Utilities.getAsProperties error: InputStream is null");
  398.             }
  399.             Properties p = new Properties();
  400.             p.load(is);
  401.             return p;
  402.         }catch(Exception e){
  403.             throw new UtilsException(e.getMessage(),e);
  404.         }
  405.     }
  406.     
  407.     public static java.util.Properties getAsProperties(byte[] content) throws UtilsException{
  408.         if(content==null){
  409.             throw new UtilsException("Utilities.getAsProperties error: Content is null");
  410.         }
  411.         try (ByteArrayInputStream bin = new ByteArrayInputStream(content);){
  412.             return getAsProperties(bin);
  413.         }catch(Exception e){
  414.             throw new UtilsException(e.getMessage(),e);
  415.         }
  416.     }
  417.     
  418.     public static java.util.Properties getAsProperties(URL url) throws UtilsException{
  419.         InputStream is = null;
  420.         try{
  421.             if(url==null){
  422.                 throw new UtilsException("Utilities.getAsProperties error: URL is null");
  423.             }
  424.             is = url.openStream();
  425.             return getAsProperties(is);
  426.         }catch(Exception e){
  427.             throw new UtilsException(e.getMessage(),e);
  428.         }
  429.         finally{
  430.             try{
  431.                 if(is!=null){
  432.                     is.close();
  433.                 }
  434.             }catch(Exception eClose){
  435.                 // close
  436.             }
  437.         }
  438.     }

  440.     /**
  441.      * Legge le proprieta' che possiedono un nome che inizia con un determinato prefisso
  442.      * 
  443.      * @param prefix
  444.      * @param sorgente java.util.Properties
  445.      * @return java.util.Properties
  446.      * @throws UtilsException
  447.      */
  448.     public static java.util.Properties readProperties (String prefix,java.util.Properties sorgente)throws UtilsException{
  449.         java.util.Properties prop = new java.util.Properties();
  450.         try{ 
  451.             java.util.Enumeration<?> en = sorgente.propertyNames();
  452.             while (en.hasMoreElements()) {
  453.                 String property = (String) en.nextElement();
  454.                 if(property.startsWith(prefix)){
  455.                     String key = (property.substring(prefix.length()));
  456.                     if(key != null)
  457.                         key = key.trim();
  458.                     String value = sorgente.getProperty(property);
  459.                     if(value!=null)
  460.                         value = value.trim();
  461.                     if(key!=null && value!=null)
  462.                         prop.setProperty(key,value);
  463.                 }
  464.             }
  465.             return prop;
  466.         }catch(java.lang.Exception e) {
  467.             throw new UtilsException("Utilities.readProperties Riscontrato errore durante la lettura delle proprieta' con prefisso ["+prefix+"]: "+e.getMessage(),e);
  468.         }  
  469.     }
  470.     /**
  471.      * Legge le proprieta' che possiedono un nome che inizia con un determinato prefisso
  472.      * 
  473.      * @param prefix
  474.      * @param key Array di chiavi
  475.      * @param name Array di nomi
  476.      * @return java.util.Properties
  477.      * @throws UtilsException
  478.      */
  479.     public static java.util.Properties readProperties (String prefix,String[]key,String[] name)throws UtilsException{
  480.         java.util.Properties sorgente = new java.util.Properties();
  481.         if(key!=null && name!=null && key.length==name.length){
  482.             for(int i=0; i<key.length; i++){
  483.                 sorgente.put(key[i], name[i]);
  484.             }
  485.         }   
  486.         return Utilities.readProperties(prefix,sorgente);
  487.     }




  492.     /**
  493.      * Converte unix_timestamp in stringa
  494.      * 
  495.      * @param time unix_timestamp
  496.      * @param millisecondiCheck Se true verranno indicati anche i millisecondi
  497.      * @return String unix_timestamp
  498.      */
  499.     public static String convertSystemTimeIntoStringMillisecondi(long time,boolean millisecondiCheck){
  500.         return convertSystemTimeIntoStringMillisecondi(time, millisecondiCheck, true, ":",".","");
  501.     }
  502.     public static String convertSystemTimeIntoStringMillisecondi(long time,boolean millisecondiCheck, boolean printZeroValues, 
  503.             String separatorUnit,String separatorMs, String separatorValue){
  504.         /**System.out.println("VALORE PASSATO: ["+time+"]");*/
  505.         long millisecondi = time % 1000;
  506.         /**System.out.println("Millisecondi (Valore%1000): ["+millisecondi+"]");*/
  507.         long diff = (time)/1000;
  508.         /**System.out.println("Diff... (valore/1000) ["+diff+"]");*/
  509.         long ore = diff/3600;
  510.         /**System.out.println("Ore... (diff/3600) ["+ore+"]");*/
  511.         long minuti = (diff%3600) / 60;
  512.         /**System.out.println("Minuti... (diff%3600) / 60 ["+minuti+"]");*/
  513.         long secondi = (diff%3600) % 60;
  514.         /**System.out.println("Secondi... (diff%3600) % 60 ["+secondi+"]");*/
  515.         StringBuilder bf = new StringBuilder();

  517.         long giorni = ore/24;
  518.         long oreRimaste = ore%24;

  520.         if(giorni>0){
  521.             bf.append(giorni);
  522.             bf.append(separatorValue);
  523.             bf.append("d");
  524.         }
  525.         else{
  526.             // Nothing
  527.         }

  529.         if(giorni>0){
  530.             if(oreRimaste>0){
  531.                 if(bf.length()>0){
  532.                     bf.append(separatorUnit);
  533.                 }
  534.                 bf.append(oreRimaste);
  535.                 bf.append(separatorValue);
  536.                 bf.append("h");
  537.             }else{
  538.                 if(printZeroValues && bf.length()>0){
  539.                     bf.append(separatorUnit);
  540.                     bf.append("0");
  541.                     bf.append(separatorValue);
  542.                     bf.append("h");
  543.                 }
  544.             }
  545.         }
  546.         else{
  547.             if(ore>0){
  548.                 if(bf.length()>0){
  549.                     bf.append(separatorUnit);
  550.                 }
  551.                 bf.append(ore);
  552.                 bf.append(separatorValue);
  553.                 bf.append("h");
  554.             }else{
  555.                 if(printZeroValues && bf.length()>0){
  556.                     bf.append(separatorUnit);
  557.                     bf.append("0");
  558.                     bf.append(separatorValue);
  559.                     bf.append("h");
  560.                 }
  561.             }
  562.         }


  565.         if(minuti>0){
  566.             if(bf.length()>0){
  567.                 bf.append(separatorUnit);
  568.             }
  569.             bf.append(minuti);
  570.             bf.append(separatorValue);
  571.             bf.append("m");
  572.         }else{
  573.             if(printZeroValues && bf.length()>0){
  574.                 bf.append(separatorUnit);
  575.                 bf.append("0");
  576.                 bf.append(separatorValue);
  577.                 bf.append("m");
  578.             }
  579.         }

  581.         if(secondi>0){
  582.             if(bf.length()>0){
  583.                 bf.append(separatorUnit);
  584.             }
  585.             bf.append(secondi);
  586.             bf.append(separatorValue);
  587.             bf.append("s");
  588.         }
  589.         else{
  590.             if(printZeroValues && bf.length()>0){
  591.                 bf.append(separatorUnit);
  592.                 bf.append("0");
  593.                 bf.append(separatorValue);
  594.                 bf.append("s");
  595.             }
  596.         }

  598.         if(millisecondiCheck){
  599.             if(millisecondi>0 || (millisecondi==0 && printZeroValues)){
  600.                 if(bf.length()>0){
  601.                     bf.append(separatorMs);
  602.                 }
  603.                 bf.append(millisecondi);
  604.                 bf.append(separatorValue);
  605.                 bf.append("ms");
  606.             }
  607.             else{
  608.                 if(printZeroValues && bf.length()>0){
  609.                     bf.append(separatorMs);
  610.                     bf.append("0");
  611.                     bf.append(separatorValue);
  612.                     bf.append("ms");
  613.                 }
  614.             }
  615.         }


  618.         if(bf.length()==0){
  619.             bf.append("conversione non riuscita");
  620.         }

  622.         return bf.toString();
  623.     }
  624.     
  625.     public static long convertSystemTimeInNumeroOre(long time){
  626.         if(time < 0)
  627.             time = 0;
  628.                 
  629.         // tempo in millisecondi diviso mille -> tempo in secondi
  630.         long diff = (time)/1000;
  631.         // tempo in ore = tempo in secondi / 60 * 60
  632.         long ore = diff/3600;
  633.         
  634.         // controllo che non ci siano parti di ora residue
  635.         if((diff%3600) != 0)
  636.             ore ++;
  637.             
  638.         return ore;
  639.     }
  640.     
  641.     public static long convertSystemTimeInNumeroGiorni(long time){
  642.         if(time < 0)
  643.             time = 0;
  644.                 
  645.         // tempo in millisecondi diviso mille -> tempo in secondi
  646.         long diff = (time)/1000;
  647.         // tempo in ore = tempo in secondi / 60 * 60
  648.         long ore = diff/3600;
  649.         
  650.         // controllo che non ci siano parti di ora residue
  651.         if((diff%3600) != 0)
  652.             ore ++;
  653.         
  654.         long giorni = ore/24;
  655.         long oreRimaste = ore%24;
  656.         
  657.         if(oreRimaste != 0)
  658.             giorni ++;
  659.         
  660.         return giorni;
  661.     }
  662.     


  665.     private static final double KB = 1024;
  666.     private static final double MB = 1048576;
  667.     private static final double GB = 1073741824;
  668.     public static String convertBytesToFormatString(long value) {
  669.         return convertBytesToFormatString(value, false, "");
  670.     }
  671.     public static String convertBytesToFormatString(long value, boolean upperCase, String separator) {

  673.         MessageFormat mf = new MessageFormat("{0,number,#.##}");
  674.         Double len = null;
  675.         String res = "";
  676.         //il valore e' in byte
  677.         len = Long.valueOf((value+"")).doubleValue();
  678.         long d = Math.round(len/Utilities.KB); 
  679.         if(d<=1){
  680.             //byte
  681.             Object[] objs = {len};
  682.             res = mf.format(objs);
  683.             res +=separator;
  684.             res += "b";
  685.         }else if(d>1 && d<1000){
  686.             //kilo byte
  687.             Object[] objs = {len/Utilities.KB};
  688.             res = mf.format(objs);
  689.             res +=separator;
  690.             res += "kb";
  691.         }else  if (d >= 1000 && d < 1000000){
  692.             //mega byte
  693.             Object[] objs = {len/Utilities.MB};
  694.             res = mf.format(objs);
  695.             res +=separator;
  696.             res += "mb";
  697.         }
  698.         else{
  699.             // giga byte
  700.             Object[] objs = { len/Utilities.GB };
  701.             res = mf.format(objs);
  702.             res +=separator;
  703.             res +="gb";
  704.         }

  706.         if(upperCase){
  707.             res = res.toUpperCase();
  708.         }
  709.         
  710.         return res;
  711.     }




  716.     /* STRING UTILS NORMALIZE NAME */
  717.     
  718.     public static String convertNameToSistemaOperativoCompatible(String nome,boolean convertCharNotPermitted,Character charJollyCharNotPermitted,
  719.             List<Character> permit, boolean addUniqueSuffixIfFoundCharNotPermitted){
  720.         StringBuilder bf = new StringBuilder();
  721.         boolean charNotPermittedFound = false;
  722.         for (int i = 0; i < nome.length(); i++) {
  723.             if(Character.isLetterOrDigit(nome.charAt(i))){
  724.                 bf.append(nome.charAt(i));
  725.             }
  726.             else {
  727.                 if(permit!=null){
  728.                     // check che sia nella lista dei caratteri permessi
  729.                     boolean found = false;
  730.                     for (char charPermit : permit) {
  731.                         if(charPermit == nome.charAt(i)){
  732.                             found = true;
  733.                             break;
  734.                         }
  735.                     }
  736.                     if(found){
  737.                         bf.append(nome.charAt(i));
  738.                         continue;
  739.                     }
  740.                 }
  741.                 
  742.                 // Se non e' nella lista dei caratteri permessi, se e' abilitata la conversione, converto il carattere non permesso nel carattere jolly
  743.                 // altrimenti lo "brucio"
  744.                 if(convertCharNotPermitted){
  745.                     // sostituisco tutto con il carattere jolly
  746.                     bf.append(charJollyCharNotPermitted);
  747.                 }
  748.                 charNotPermittedFound = true;
  749.             }
  750.         }
  751.         if(charNotPermittedFound && addUniqueSuffixIfFoundCharNotPermitted){
  752.             bf.append("_");
  753.             bf.append(getNextCounterFile());
  754.         }
  755.         return bf.toString();
  756.     }
  757.     private static int counterFileNameWithCharNotPermitted = 0;
  758.     private static synchronized int getNextCounterFile(){
  759.         if(counterFileNameWithCharNotPermitted==Integer.MAX_VALUE){
  760.             counterFileNameWithCharNotPermitted = 0;
  761.         }
  762.         counterFileNameWithCharNotPermitted++;
  763.         return counterFileNameWithCharNotPermitted;
  764.     }
  765.     
  766.     
  767.     public static String camelCase(String value) {
  768.         char [] delimiters = new char[] {'.' , '_' , '-' , ':' , ';' , ',' , ' ' };
  769.         return camelCase(delimiters, value);
  770.     }
  771.     public static String camelCase(char [] delimiters, String value) {
  772.                 
  773.         String s = WordUtils.capitalizeFully(value, delimiters);
  774.         for (int i = 0; i < delimiters.length; i++) {
  775.             String c = delimiters[i]+"";
  776.             while(s.contains(c)) {
  777.                 s = s.replace(c, "");
  778.             }
  779.         }
  780.         
  781.         return s;
  782.     }
  783.     
  784.     
  785.     
  786.     
  787.     
  788.     /* STRING UTILS CON ESCAPE */
  789.     
  790.     public static String[] split(String value, char separator) throws UtilsException{
  791.         
  792.         StringBuilder bf = new StringBuilder();
  793.         List<String> splitResults = new ArrayList<>();
  794.         if(value==null || value.length()<=0){
  795.             throw new UtilsException("Valore non fornito");
  796.         }
  797.         for (int i = 0; i < value.length(); i++) {
  798.             if(value.charAt(i) == separator){
  799.                 
  800.                 if(
  801.                         (i>0 && (value.charAt(i-1) != '\\'))
  802.                                 ||
  803.                         (i==0)
  804.                 ){
  805.                     splitResults.add(bf.toString());
  806.                     bf.delete(0, bf.length());
  807.                 }
  808.                 else{
  809.                     bf.append(value.charAt(i));
  810.                 }
  811.             }
  812.             else{
  813.                 bf.append(value.charAt(i));
  814.             }
  815.         }
  816.         
  817.         splitResults.add(bf.toString());
  818.         return splitResults.toArray(new String[1]);
  819.     }

  821.     

  823.     
  824.     




  829.     // Metodi per il logging dell'heap space

  831.     private static boolean freeMemoryLog = false;
  832.     public static boolean isFreeMemoryLog() {
  833.         return freeMemoryLog;
  834.     }
  835.     public static void setFreeMemoryLog(boolean freeMemoryLog) {
  836.         Utilities.freeMemoryLog = freeMemoryLog;
  837.     }
  838.     private static Logger log;
  839.     public static void setLog(Logger log) {
  840.         Utilities.log = log;
  841.     }
  842.     public static final Runtime s_runtime = Runtime.getRuntime ();
  843.     public static final long INITIAL_SIZE = Utilities.s_runtime.freeMemory();
  844.     public static void printFreeMemory(String descr){
  845.         if(Utilities.freeMemoryLog){
  846.             long currentSize = Utilities.s_runtime.freeMemory();
  847.             String msg = "[Free Memory Space]" + "[CURRENT: " + Utilities.convertBytesToFormatString(currentSize) + "] [DIFF: " + Utilities.convertBytesToFormatString(Utilities.INITIAL_SIZE - Utilities.s_runtime.freeMemory()) + "] " + descr;
  848.             Utilities.log.debug(msg);
  849.         }
  850.     }






  857.     // Gestione eccezioni
  858.     
  859.     public static String readFirstErrorValidMessageFromException(Throwable e) {
  860.         if(e instanceof NullPointerException) {
  861.              return "NullPointerException";
  862.         }else {
  863.             Throwable inner = Utilities.getInnerNotEmptyMessageException(e);
  864.             if(inner!=null) {
  865.                 return inner.getMessage();
  866.             }
  867.             else {
  868.                 if(Utilities.isEmpytMessageException(e)) {
  869.                     return e.toString();
  870.                 }
  871.                 else {
  872.                     return e.getMessage();
  873.                 }
  874.             }
  875.         }
  876.     }
  877.     
  878.     public static boolean isEmpytMessageException(Throwable e){
  879.         return e==null || e.getMessage()==null ||
  880.                 "".equals(e.getMessage()) || 
  881.                 "null".equalsIgnoreCase(e.getMessage());
  882.     }
  883.     
  884.     public static boolean existsInnerInstanceException(Throwable e,Class<?> found){
  885.         if(found.isInstance(e) ){
  886.             return true;
  887.         }else{
  888.             if(e.getCause()!=null){
  889.                 return Utilities.existsInnerInstanceException(e.getCause(), found);
  890.             }
  891.             else{
  892.                 return false;
  893.             }
  894.         }
  895.     }
  896.     public static boolean existsInnerInstanceException(Throwable e,String found) throws ClassNotFoundException{
  897.         return Utilities.existsInnerInstanceException(e,Class.forName(found));
  898.     }
  899.     
  900.     public static Throwable getInnerInstanceException(Throwable e,Class<?> found, boolean last){
  901.         if(found.isInstance(e) ){
  902.             
  903.             if(last) {
  904.                 if(e.getCause()!=null && existsInnerInstanceException(e.getCause(), found)) {
  905.                     return Utilities.getInnerInstanceException(e.getCause(), found, last);
  906.                 }
  907.                 else {
  908.                     return e;
  909.                 }
  910.             }
  911.             else {
  912.                 return e;
  913.             }
  914.         }else{
  915.             if(e.getCause()!=null){
  916.                 return Utilities.getInnerInstanceException(e.getCause(), found, last);
  917.             }
  918.             else{
  919.                 return null;
  920.             }
  921.         }
  922.     }
  923.     public static Throwable getInnerInstanceException(Throwable e,String found, boolean last) throws ClassNotFoundException{
  924.         return Utilities.getInnerInstanceException(e,Class.forName(found), last);
  925.     }
  926.     
  927.     public static boolean existsInnerException(Throwable e,Class<?> found){
  928.         return Utilities.existsInnerException(e,found.getName());
  929.     }
  930.     public static boolean existsInnerException(Throwable e,String found){
  931.         if(e.getClass().getName().equals(found) ){
  932.             return true;
  933.         }else{
  934.             if(e.getCause()!=null){
  935.                 return Utilities.existsInnerException(e.getCause(), found);
  936.             }
  937.             else{
  938.                 return false;
  939.             }
  940.         }
  941.     }

  943.     public static Throwable getInnerException(Throwable e,Class<?> found){
  944.         return Utilities.getInnerException(e,found.getName());
  945.     }
  946.     public static Throwable getInnerException(Throwable e,String found){
  947.         if(e.getClass().getName().equals(found) ){
  948.             return e;
  949.         }else{
  950.             if(e.getCause()!=null){
  951.                 return Utilities.getInnerException(e.getCause(), found);
  952.             }
  953.             else{
  954.                 return null;
  955.             }
  956.         }
  957.     }

  959.     public static Throwable getLastInnerException(Throwable e){
  960.         if(e.getCause()==null){
  961.             return e;
  962.         }
  963.         else{
  964.             return Utilities.getLastInnerException(e.getCause());
  965.         }
  966.     }

  968.     public static boolean existsInnerMessageException(Throwable e,String msg,boolean contains){
  969.         boolean search = false;
  970.         if(contains){
  971.             search = e.getMessage()!=null && e.getMessage().contains(msg);
  972.         }else{
  973.             search = e.getMessage()!=null && e.getMessage().equals(msg);
  974.         }
  975.         if( search ){
  976.             return true;
  977.         }else{
  978.             if(e.getCause()!=null){
  979.                 return Utilities.existsInnerMessageException(e.getCause(), msg, contains);
  980.             }
  981.             else{
  982.                 return false;
  983.             }
  984.         }
  985.     }

  987.     public static Throwable getInnerMessageException(Throwable e,String msg,boolean contains){
  988.         boolean search = false;
  989.         if(contains){
  990.             search = e.getMessage()!=null && e.getMessage().contains(msg);
  991.         }else{
  992.             search = e.getMessage()!=null && e.getMessage().equals(msg);
  993.         }
  994.         if( search ){
  995.             return e;
  996.         }else{
  997.             if(e.getCause()!=null){
  998.                 return Utilities.getInnerMessageException(e.getCause(), msg, contains);
  999.             }
  1000.             else{
  1001.                 return null;
  1002.             }
  1003.         }
  1004.     }


  1007.     public static Throwable getInnerNotEmptyMessageException(Throwable e){
  1008.         if(e.getMessage()!=null && !"".equals(e.getMessage()) && !"null".equalsIgnoreCase(e.getMessage())){
  1009.             return e;
  1010.         }

  1012.         if(e.getCause()!=null){
  1013.             return Utilities.getInnerNotEmptyMessageException(e.getCause());
  1014.         }
  1015.         else{
  1016.             return e; // sono nella foglia, ritorno comunque questa eccezione
  1017.         }
  1018.     }


  1021.     public static boolean isExceptionInstanceOf(Class<?> c,Throwable t){
  1022.         return isExceptionInstanceOf(c.getName(), t);
  1023.     }
  1024.     public static boolean isExceptionInstanceOf(String className,Throwable t){
  1025.         if(t.getClass().getName().equals(className)){
  1026.             return true;
  1027.         }
  1028. /**     else if(t.getClass().getSuperclass()!=null && t.getClass().getSuperclass().equals(className)){
  1029.             return true;
  1030.         }*/
  1031.         else{
  1032.             try{
  1033.                 Class<?> c = Class.forName(className); 
  1034.                 return c.isInstance(t);
  1035.             }catch(Exception tException){
  1036.                 return false;
  1037.             }
  1038.         }
  1039.     }







  1047.     // ** Elimina un attributo xml che contiene la keyword indicata nel secondo parametro */

  1049.     public static String eraserXmlAttribute(String tmp,String keyword){
  1050.         int indexOfValueWrong = tmp.indexOf(keyword);
  1051.         while(indexOfValueWrong>0){

  1053.             StringBuilder bf = new StringBuilder();
  1054.             int index = indexOfValueWrong-1;
  1055.             while(tmp.charAt(index) != ' '){
  1056.                 bf.append(tmp.charAt(index));
  1057.                 index--;
  1058.             }

  1060.             StringBuilder replaceString = new StringBuilder();
  1061.             for (int i = (bf.toString().length()-1); i >=0; i--) {
  1062.                 replaceString.append(bf.toString().charAt(i));
  1063.             }
  1064.             replaceString.append(keyword);

  1066.             index = indexOfValueWrong+keyword.length();
  1067.             while( (tmp.charAt(index) != ' ') && (tmp.charAt(index) != '>') ){
  1068.                 replaceString.append(tmp.charAt(index));
  1069.                 index++;
  1070.             }

  1072.             tmp = StringUtils.replace(tmp, replaceString.toString(), "");

  1074.             indexOfValueWrong = tmp.indexOf(keyword);
  1075.         }
  1076.         return tmp;
  1077.     }










  1088.     // ** Traduce in String un byte[] se il testo è visualizzabile **
  1089.     public static String getErrorMessagePrintableTextMaxLength(int length, int maxLength) {
  1090.         return "Visualizzazione non riuscita: la dimensione del pacchetto fornito ("+Utilities.convertBytesToFormatString(length)+") supera il limite consentito ("+Utilities.convertBytesToFormatString(maxLength)+")";
  1091.     }
  1092.     public static String convertToPrintableText(byte [] b,int maxBytes) throws UtilsException{
  1093.         try (ByteArrayOutputStream bout = new ByteArrayOutputStream();){

  1095.             if(b.length>maxBytes){
  1096.                 throw new UtilsException(getErrorMessagePrintableTextMaxLength(b.length,maxBytes));
  1097.             }

  1099.             for (int i = 0; i < b.length; i++) {
  1100.                 if(!Utilities.isPrintableChar((char)b[i])){
  1101.                     throw new UtilsException("Visualizzazione non riuscita: il documento contiene caratteri non visualizzabili");
  1102.                 }
  1103.             }

  1105.             bout.write(b);
  1106.             bout.flush();
  1107.             return bout.toString();
  1108.             
  1109.         }
  1110.         catch(UtilsException e){
  1111.             throw e;
  1112.         }
  1113.         catch(Exception e){
  1114.             throw new UtilsException("Visualizzazione non riuscita: Documento binario?",e);
  1115.         }

  1117.     }

  1119.     public static boolean isPrintableChar( char c ) {
  1120.         return Character.isDefined(c);
  1121.     }
  1122.     
  1123.     
  1124.     
  1125.     
  1126.     
  1127.     
  1128.     
  1129.     
  1130.     
  1131.     
  1132.     // ** Locale **
  1133.     
  1134.     public static String toString(java.util.Locale locale){
  1135.         return toString(locale,"\n");
  1136.     }
  1137.     public static String toString(java.util.Locale locale, String separator){
  1138.         StringBuilder bf = new StringBuilder();
  1139.         toString(locale,bf,separator);
  1140.         return bf.toString();
  1141.     }
  1142.     public static void toString(java.util.Locale locale, StringBuilder bf, String separator){
  1143.         
  1144.         bf.append(locale.getDisplayName());
  1145.         bf.append(separator);
  1146.         
  1147.         addLanguage(locale, bf, separator);
  1148.         
  1149.         addCountry(locale, bf, separator);
  1150.                 
  1151.         bf.append("Script: ");
  1152.         if(locale.getScript()!=null && !"".equals(locale.getScript().trim())){
  1153.             bf.append(locale.getScript());
  1154.             bf.append(" (");
  1155.             bf.append(locale.getDisplayScript());
  1156.             bf.append(")");
  1157.         }
  1158.         else{
  1159.             bf.append("-");
  1160.         }
  1161.         bf.append(separator);
  1162.         
  1163.         bf.append("Variant: ");
  1164.         if(locale.getVariant()!=null && !"".equals(locale.getVariant().trim())){
  1165.             bf.append(locale.getVariant());
  1166.             bf.append(" (");
  1167.             bf.append(locale.getDisplayVariant());
  1168.             bf.append(")");
  1169.         }
  1170.         else{
  1171.             bf.append("-");
  1172.         }
  1173.         bf.append(separator);
  1174.         
  1175.         /**Iterator<String> it = locale.getUnicodeLocaleAttributes().iterator();
  1176.         while (it.hasNext()) {
  1177.             String attribute = (String) it.next();
  1178.             bf.append("Attribute["+attribute+"]");
  1179.             bf.append(separator);
  1180.         }
  1181.         
  1182.         Iterator<Character> itC = locale.getExtensionKeys().iterator();
  1183.         while (itC.hasNext()) {
  1184.             Character character = (Character) itC.next();
  1185.             bf.append("Extension["+character+"]=["+locale.getExtension(character)+"]");
  1186.             bf.append(separator);
  1187.         }
  1188.         
  1189.         it = locale.getUnicodeLocaleKeys().iterator();
  1190.         while (it.hasNext()) {
  1191.             String key = (String) it.next();
  1192.             bf.append("Key["+key+"]=["+locale.getUnicodeLocaleType(key)+"]");
  1193.             bf.append(separator);
  1194.         }*/
  1195.     
  1196.     }
  1197.     private static void addLanguage(java.util.Locale locale, StringBuilder bf, String separator) {
  1198.         bf.append("Language: ");
  1199.         if(locale.getLanguage()!=null && !"".equals(locale.getLanguage().trim())){
  1200.             bf.append(locale.getLanguage());
  1201.             bf.append(" (");
  1202.             bf.append(locale.getDisplayLanguage());
  1203.             bf.append(") [ISO3:");
  1204.             try{
  1205.                 if(locale.getISO3Language()!=null){
  1206.                     bf.append(locale.getISO3Language());
  1207.                 }
  1208.                 else{
  1209.                     bf.append("-");
  1210.                 }
  1211.             }catch(Exception e){
  1212.                 bf.append(e.getMessage());
  1213.             }
  1214.             bf.append("]"); 
  1215.         }
  1216.         else{
  1217.             bf.append("-");
  1218.         }
  1219.         bf.append(separator);
  1220.     }
  1221.     private static void addCountry(java.util.Locale locale, StringBuilder bf, String separator) {
  1222.         bf.append("Country: ");
  1223.         if(locale.getCountry()!=null && !"".equals(locale.getCountry().trim())){
  1224.             bf.append(locale.getCountry());
  1225.             bf.append(" (");
  1226.             bf.append(locale.getDisplayCountry());
  1227.             bf.append(") [ISO3:");
  1228.             try{
  1229.                 if(locale.getISO3Language()!=null){
  1230.                     bf.append(locale.getISO3Country());
  1231.                 }
  1232.                 else{
  1233.                     bf.append("-");
  1234.                 }
  1235.             }catch(Exception e){
  1236.                 bf.append(e.getMessage());
  1237.             }
  1238.             bf.append("]"); 
  1239.         }
  1240.         else{
  1241.             bf.append("-");
  1242.         }
  1243.         bf.append(separator);
  1244.     }
  1245.     
  1246.     
  1247.     
  1248.     // ** TimeZone **
  1249.     
  1250.     public static String toString(java.util.TimeZone timeZone){
  1251.         return toString(timeZone,false);
  1252.     }
  1253.     public static String toString(java.util.TimeZone timeZone, boolean allInfo){
  1254.         StringBuilder bf = new StringBuilder();
  1255.         toString(timeZone,bf,allInfo);
  1256.         return bf.toString();
  1257.     }
  1258.     public static void toString(java.util.TimeZone timeZone, StringBuilder bf, boolean allInfo){
  1259.         bf.append(timeZone.getID());
  1260.         bf.append(" (");
  1261.         bf.append(timeZone.getDisplayName());
  1262.         bf.append(")");
  1263.         if(allInfo){
  1264.             bf.append(" DSTSaving:");
  1265.             bf.append(timeZone.getDSTSavings());
  1266.             bf.append(" RawOffset:");
  1267.             bf.append(timeZone.getRawOffset());
  1268.         }
  1269.     }
  1270.     
  1271.     
  1272.     // ** URL **
  1273.     
  1274.     public static String buildUrl(String prefix, String contesto) {
  1275.         String url = prefix;
  1276.         if(contesto!=null && !"".equals(contesto)) {
  1277.             if(!url.endsWith("/")) {
  1278.                 if(!contesto.startsWith("/")) {
  1279.                     url = url +"/";
  1280.                 }
  1281.             }
  1282.             else {
  1283.                 if(contesto.startsWith("/") && contesto.length()>1) {
  1284.                     contesto = contesto.substring(1);
  1285.                 }
  1286.             }
  1287.             url = url + contesto;
  1288.         }
  1289.         return url;
  1290.     }
  1291.     
  1292.     
  1293.     // ** ConcurrentHashMap **
  1294.     
  1295.     public static ConcurrentMap<String, String> convertToConcurrentHashMap(Properties map) {
  1296.         ConcurrentMap<String, String> mapReturnNull = null;
  1297.         if(map==null || map.isEmpty()) {
  1298.             return mapReturnNull;
  1299.         }
  1300.         ConcurrentHashMap<String, String> newMap = new ConcurrentHashMap<>();
  1301.         Iterator<Object> it = map.keySet().iterator();
  1302.         while (it.hasNext()) {
  1303.             Object k = it.next();
  1304.             if(k instanceof String) {
  1305.                 String key = (String)k;
  1306.                 newMap.put(key, map.getProperty(key));
  1307.             }
  1308.         }
  1309.         return newMap;
  1310.     }
  1311.     public static <K,V> ConcurrentMap<K, V> convertToConcurrentHashMap(Map<K, V> map) {
  1312.         ConcurrentMap<K,V> mapReturnNull = null;
  1313.         if(map==null || map.isEmpty()) {
  1314.             return mapReturnNull;
  1315.         }
  1316.         ConcurrentHashMap<K, V> newMap = new ConcurrentHashMap<>();
  1317.         Iterator<K> it = map.keySet().iterator();
  1318.         while (it.hasNext()) {
  1319.             K k = it.next();
  1320.             newMap.put(k, map.get(k));
  1321.         }
  1322.         return newMap;
  1323.     }
  1324.     
  1325.     // ** HashMap **
  1326.     
  1327.     public static Map<String, String> convertToHashMap(Properties map) {
  1328.         Map<String, String> mapReturnNull = null;
  1329.         if(map==null || map.isEmpty()) {
  1330.             return mapReturnNull;
  1331.         }
  1332.         HashMap<String, String> newMap = new HashMap<>();
  1333.         Iterator<Object> it = map.keySet().iterator();
  1334.         while (it.hasNext()) {
  1335.             Object k = it.next();
  1336.             if(k instanceof String) {
  1337.                 String key = (String)k;
  1338.                 newMap.put(key, map.getProperty(key));
  1339.             }
  1340.         }
  1341.         return newMap;
  1342.     }
  1343.     
  1344.     
  1345.     
  1346.     
  1347.     
  1348.     
  1349.     
  1350.     // ** S.O. **
  1351.     
  1352.     public static boolean isOSUnix() {
  1353.         return SystemUtils.IS_OS_UNIX;
  1354.     }
  1355.     public static boolean isOSWindows() {
  1356.         return SystemUtils.IS_OS_WINDOWS;
  1357.     }
  1358.     public static boolean isOSMac() {
  1359.         return SystemUtils.IS_OS_MAC;
  1360.     }
  1361.     
  1362.     
  1363.     
  1364.     
  1365.     // ** File temporaneo **
  1366.     
  1367.     public static Path createTempPath(String prefix, String suffix) throws IOException{
  1368.         return createTempPath(null, prefix, suffix);
  1369.     }
  1370.     public static Path createTempPath(Path dir, String prefix, String suffix) throws IOException{
  1371.         // Make sure publicly writable directories are used safely here.
  1372.         // Using publicly writable directories is security-sensitivejava:S5443
  1373.         if(SystemUtils.IS_OS_UNIX) {
  1374.             FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(PosixFilePermissions.fromString("rwx------"));
  1375.             return dir!=null ? Files.createTempFile(dir, prefix, suffix, attr) : Files.createTempFile(prefix, suffix, attr);
  1376.         }
  1377.         else {
  1378.             final File f = dir!=null ? Files.createTempFile(dir, prefix, suffix).toFile() : Files.createTempFile(org.apache.commons.io.FileUtils.getTempDirectory().toPath(), prefix, suffix).toFile(); 
  1379.             if(!f.setReadable(true, true)) {
  1380.                 // ignore
  1381.             }
  1382.             if(!f.setWritable(true, true)) {
  1383.                 // ignore
  1384.             }
  1385.             if(!f.setExecutable(true, true)) {
  1386.                 // ignore
  1387.             }
  1388.             return f.toPath();
  1389.         }
  1390.     }
  1391.     
  1392.     
  1393.     
  1394.     
  1395.     // ** ENV **
  1396.     
  1397.     public static void setEnvProperty(String key, String value) throws UtilsException {
  1398.         try {
  1399.             Map<String, String> env = System.getenv();
  1400.             Class<?> c = env.getClass();
  1401.             Field field = c.getDeclaredField("m");
  1402.             field.setAccessible(true);
  1403.             @SuppressWarnings("unchecked")
  1404.             Map<String, String> wEnv = (Map<String, String>) field.get(env);
  1405.             wEnv.put(key, value);
  1406.         } catch (Exception e) {
  1407.             throw new UtilsException("setEnvProperty '"+key+"' failed: "+e.getMessage(), e);
  1408.         }
  1409.     }
  1410. }
Created with JaCoCo 0.8.8.202204050719