BaseBean.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.  */
  20. package org.openspcoop2.utils.beans;

  22. import java.io.ByteArrayOutputStream;
  23. import java.io.OutputStream;
  24. import java.io.Serializable;
  25. import java.lang.reflect.InvocationTargetException;
  26. import java.lang.reflect.Method;
  27. import java.util.ArrayList;
  28. import java.util.List;

  30. import javax.xml.bind.annotation.XmlTransient;

  32. import org.apache.commons.lang.builder.ReflectionToStringBuilder;
  33. import org.apache.commons.lang.builder.ToStringStyle;
  34. import org.openspcoop2.utils.UtilsException;
  35. import org.openspcoop2.utils.UtilsRuntimeException;
  36. import org.openspcoop2.utils.date.DateUtils;
  37. import org.openspcoop2.utils.serialization.ISerializer;
  38. import org.openspcoop2.utils.serialization.JavaSerializer;
  39. import org.openspcoop2.utils.serialization.SerializationConfig;
  40. import org.openspcoop2.utils.serialization.SerializationFactory;
  41. import org.openspcoop2.utils.serialization.SerializationFactory.SERIALIZATION_TYPE;
  42. import org.openspcoop2.utils.xml.JaxbUtils;

  44. /**
  45.  * BaseBean
  46.  *
  47.  * @author Poli Andrea (apoli@link.it)
  48.  * @author $Author$
  49.  * @version $Rev$, $Date$
  50.  */
  51. @XmlTransient
  52. public abstract class BaseBean implements Serializable {

  54.     private static final long serialVersionUID = 1L;
  55.     
  56.     private static final String TO_STRING_METHOD = "toString";
  57.     
  58.     protected BaseBean(){
  59.         // nop
  60.     }
  61.     
  62.     private void logExceptionStackTrace(Exception e) {
  63.         e.printStackTrace(System.err);
  64.     }
  65.     
  66.     /* ********** GENERIC UTILS ********* */
  67.     
  68.     private Object getFieldValue(String fieldName,Object object) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
  69.         Class<?> c = getClass();
  70.         
  71.         StringBuilder methodName = new StringBuilder("get");
  72.         String firstChar = fieldName.charAt(0)+"";
  73.         methodName.append(firstChar.toUpperCase());
  74.         if(fieldName.length()>1){
  75.             methodName.append(fieldName.substring(1));
  76.         }
  77.         
  78.         Method method = null;
  79.         try{
  80.             method = c.getMethod(methodName.toString());
  81.         }catch(java.lang.NoSuchMethodException nsme){
  82.             if("get_default".equals(methodName.toString())){
  83.                 // provo a recuperare getDefault
  84.                 try{
  85.                     method = c.getMethod("getDefault");
  86.                 }catch(Exception t){
  87.                     throw nsme; // rilancio eccezione originale
  88.                 }
  89.             }
  90.             else{
  91.                 throw nsme; // rilancio eccezione originale
  92.             }
  93.         }
  94.         return method.invoke(object);
  95.     }
  96.     
  97.     private Object setFieldValue(String fieldName,Object object,Class<?> parameterType,Object parameterValue) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
  98.         Class<?> c = getClass();
  99.         
  100.         StringBuilder methodName = new StringBuilder("set");
  101.         String firstChar = fieldName.charAt(0)+"";
  102.         methodName.append(firstChar.toUpperCase());
  103.         if(fieldName.length()>1){
  104.             methodName.append(fieldName.substring(1));
  105.         }
  106.         
  107.         Method method = null;
  108.         try{
  109.             method = c.getMethod(methodName.toString(),parameterType);
  110.         }catch(java.lang.NoSuchMethodException nsme){
  111.             if("set_default".equals(methodName.toString())){
  112.                 // provo a recuperare setDefault
  113.                 try{
  114.                     method = c.getMethod("setDefault",parameterType);
  115.                 }catch(Exception t){
  116.                     throw nsme; // rilancio eccezione originale
  117.                 }
  118.             }
  119.             else{
  120.                 throw nsme; // rilancio eccezione originale
  121.             }
  122.         }
  123.         return method.invoke(object,parameterValue);
  124.     }
  125.     
  126.     
  127.     
  128.     
  129.     
  130.     // Non lo si vuole realizzare, si demanda eventualmente alla classe che lo implementa
  131.     // Se lo si aggiunge poi viene invocato l'equals e per alcuni field per cui non esiste il metodo get si ottiene errore (es. transazioneBean)
  132.     /**@Override
  133.     public int hashCode(){
  134.         return this.getClass().getName().hashCode();
  135.     }*/
  136.     
  137.     /* ********** EQUALS ********* */
  138.     
  139.     @Override
  140.     public boolean equals(Object object){
  141.         return this.equalsEngine(object,null);
  142.     }
  143.     public boolean equals(Object object,boolean checkLongId){
  144.         List<String> listFieldsNotCheck = new ArrayList<>();
  145.         if(!checkLongId){
  146.             listFieldsNotCheck.add("id");
  147.         }
  148.         return this.equalsEngine(object, listFieldsNotCheck);
  149.     }
  150.     public boolean equals(Object object,List<String> fieldsNotCheck){
  151.         return this.equalsEngine(object, fieldsNotCheck);
  152.     }
  153.     @SuppressWarnings("unchecked")
  154.     private boolean equalsEngine(Object object,List<String> fieldsNotCheck){
  155.         try{
  156.             if(object==null){
  157.                 return false;
  158.             }
  159.             java.lang.reflect.Field[] fields = getClass().getDeclaredFields();
  160.             for(int i=0; i<fields.length;i++){
  161.                 
  162.                 /**System.out.println("["+fields[i].getName()+"]");*/
  163.                 if(java.lang.reflect.Modifier.isStatic(fields[i].getModifiers())){
  164.                     /**System.out.println("IS STATIC");*/
  165.                     continue;
  166.                 }
  167.                 
  168.                 if(fields[i].getType().isAssignableFrom(org.openspcoop2.utils.jaxb.DecimalWrapper.class)){
  169.                     continue;
  170.                 }
  171.                 
  172.                 // field id non controllato se in fieldsNotCheckList
  173.                 boolean ignoreField = false;
  174.                 if(fieldsNotCheck!=null && !fieldsNotCheck.isEmpty()){
  175.                     for (String fieldName : fieldsNotCheck) {
  176.                         if(fieldName.equals(fields[i].getName())){
  177.                             ignoreField = true;
  178.                             break;
  179.                         }
  180.                     }
  181.                 }
  182.                 if(ignoreField){
  183.                     continue;
  184.                 }
  185.                 
  186.                 Object fieldValueThis = this.getFieldValue(fields[i].getName(),this);
  187.                 Object fieldValueObject = this.getFieldValue(fields[i].getName(),object);
  188.                 /**System.out.println("LETTO VALORE["+fieldValue+"]");*/
  189.                 
  190.                 if(fieldValueThis==null){
  191.                     // FIELD
  192.                     if(fieldValueObject!=null){
  193.                         return false;
  194.                     }
  195.                 }else{
  196.                     // ARRAY_LIST
  197.                     if( (fields[i].getType().isAssignableFrom(java.util.ArrayList.class)) || (fields[i].getType().isAssignableFrom(java.util.List.class)) ){
  198.                         java.util.List<?> listaThis = (java.util.List<?>) fieldValueThis;
  199.                         java.util.List<?> listaParameter = (java.util.List<?>) fieldValueObject;
  200.                         if(listaParameter==null)
  201.                             return false;
  202.                         if(listaThis.size() != listaParameter.size())
  203.                             return false;
  204.                         for(int j=0; j<listaThis.size(); j++){
  205.                             if(listaThis.get(j)==null &&
  206.                                 listaParameter.get(j)!=null) {
  207.                                 return false;
  208.                             }
  209.                         }
  210.                         // SORT
  211.                         java.util.List<Object> listaThisSORT = new java.util.ArrayList<>();
  212.                         java.util.List<Object> listaParameterSORT = new java.util.ArrayList<>();
  213.                         try{
  214.                             java.util.List<String> listaThisTMP = new java.util.ArrayList<>();
  215.                             java.util.Map<String, Object> thisTmp = new java.util.HashMap<>();
  216.                             java.util.Map<String, Object> parameterTmp = new java.util.HashMap<>();
  217.                             for(int k=0; k<listaThis.size(); k++){
  218.                                 Object thisObject = listaThis.get(k);
  219.                                 Object paramObject = listaParameter.get(k);
  220.                                 if(thisObject==null && paramObject!=null)
  221.                                     throw new UtilsException("DIFF");
  222.                                 if(thisObject!=null && paramObject==null)
  223.                                     throw new UtilsException("DIFF");
  224.                                 if(thisObject!=null && paramObject!=null){
  225.                                     // THIS
  226.                                     String key = null;
  227.                                     if(thisObject.getClass().getName().startsWith(this.getClass().getPackage().getName())){
  228.                                         Class<?> c =  thisObject.getClass();
  229.                                         java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class,boolean.class);
  230.                                         key = (String) method.invoke(thisObject,false,true);
  231.                                     }else{
  232.                                         key = thisObject.toString();
  233.                                     }
  234.                                     thisTmp.put(key, thisObject);
  235.                                     listaThisTMP.add(key);

  237.                                     // PARAM
  238.                                     if(paramObject.getClass().getName().startsWith(this.getClass().getPackage().getName())){
  239.                                         Class<?> c =  paramObject.getClass();
  240.                                         java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class,boolean.class);
  241.                                         key = (String) method.invoke(paramObject,false,true);
  242.                                     }else{
  243.                                         key = paramObject.toString();
  244.                                     }
  245.                                     parameterTmp.put(key, paramObject);
  246.                                 }
  247.                             }
  248.                             java.util.Collections.sort(listaThisTMP);
  249.                             for(int k=0; k<listaThisTMP.size(); k++){
  250.                                 String key = listaThisTMP.get(k);
  251.                                 Object thisObject = thisTmp.get(key);
  252.                                 Object paramObject = parameterTmp.get(key);
  253.                                 if(thisObject==null || paramObject==null){
  254.                                     // significa che manca un elemento
  255.                                     return false;
  256.                                 }
  257.                                 listaThisSORT.add(thisObject);
  258.                                 listaParameterSORT.add(paramObject);
  259.                             }
  260.                         }
  261.                         catch(RuntimeException e){
  262.                             // By SpotBugs
  263.                             listaParameterSORT = (java.util.List<Object>) listaParameter;
  264.                             listaThisSORT = (java.util.List<Object>) listaThis;
  265.                         }
  266.                         catch(Exception e){
  267.                             listaThisSORT = (java.util.List<Object>) listaThis;
  268.                             listaParameterSORT = (java.util.List<Object>) listaParameter;
  269.                         }
  270.                         for(int j=0; j<listaThisSORT.size(); j++){
  271.                             Class<?> c =  listaThisSORT.get(j).getClass();
  272.                             boolean resultMethod = false;
  273.                             if(listaThis.get(j).getClass().getName().startsWith(this.getClass().getPackage().getName())){
  274.                                 java.lang.reflect.Method method =  c.getMethod("equals",Object.class,List.class);
  275.                                 resultMethod = (Boolean) method.invoke(listaThisSORT.get(j),listaParameterSORT.get(j),fieldsNotCheck);
  276.                             }else{
  277.                                 resultMethod = listaThisSORT.get(j).equals(listaParameterSORT.get(j));
  278.                             }
  279.                             if(!resultMethod)
  280.                                 return false;
  281.                         }
  282.                     }else{
  283.                         boolean resultMethod = false;
  284.                         if(fields[i].getType().getName().startsWith(this.getClass().getPackage().getName())){
  285.                             java.lang.reflect.Method method =  fields[i].getType().getMethod("equals",Object.class,List.class);
  286.                             resultMethod = (Boolean) method.invoke(fieldValueThis,fieldValueObject,fieldsNotCheck);
  287.                         }else{
  288.                             boolean checkUguaglianza = false;
  289.                             if(fields[i].getType().isAssignableFrom(byte[].class)){
  290.                                 if(fieldValueObject!=null){
  291.                                     byte[] origi = (byte[]) fieldValueThis;
  292.                                     byte[] dest = (byte[]) fieldValueObject;
  293.                                     checkUguaglianza = (origi.length == dest.length);
  294.                                     if(checkUguaglianza){
  295.                                         for(int k=0;k<origi.length;k++){
  296.                                             if(origi[k]!=dest[k]){
  297.                                                 checkUguaglianza = false;
  298.                                                 break;
  299.                                             }
  300.                                         }
  301.                                     }
  302.                                 }
  303.                             }else{
  304.                                 if(fields[i].getType().isAssignableFrom(java.util.Date.class)){
  305.                                     if(fieldValueObject==null) {
  306.                                         checkUguaglianza=false; // che fieldValue_this non sia null e' gia' stato controllato sopra
  307.                                     }
  308.                                     else {
  309.                                         java.util.Calendar calendarThis = new java.util.GregorianCalendar();
  310.                                         calendarThis.setTime((java.util.Date)fieldValueThis);
  311.                                         java.util.Calendar calendarObject = new java.util.GregorianCalendar();
  312.                                         calendarObject.setTime((java.util.Date)fieldValueObject);
  313.                                         checkUguaglianza = (  calendarThis.get(java.util.Calendar.YEAR) == calendarObject.get(java.util.Calendar.YEAR) ) && 
  314.                                                 ( calendarThis.get(java.util.Calendar.MONTH) == calendarObject.get(java.util.Calendar.MONTH) ) && 
  315.                                                 ( calendarThis.get(java.util.Calendar.DAY_OF_MONTH) == calendarObject.get(java.util.Calendar.DAY_OF_MONTH) ) && 
  316.                                                 ( calendarThis.get(java.util.Calendar.HOUR_OF_DAY) == calendarObject.get(java.util.Calendar.HOUR_OF_DAY) ) && 
  317.                                                 ( calendarThis.get(java.util.Calendar.MINUTE) == calendarObject.get(java.util.Calendar.MINUTE) ) && 
  318.                                                 ( calendarThis.get(java.util.Calendar.SECOND) == calendarObject.get(java.util.Calendar.SECOND) ) && 
  319.                                                 ( calendarThis.get(java.util.Calendar.MILLISECOND) == calendarObject.get(java.util.Calendar.MILLISECOND) ) ;
  320.                                     }
  321.                                 }else{
  322.                                     checkUguaglianza = fieldValueThis.equals(fieldValueObject);
  323.                                 }
  324.                             }
  325.                             resultMethod = checkUguaglianza;
  326.                         }
  327.                         if(!resultMethod)
  328.                             return false;
  329.                     }
  330.                 }
  331.             }
  332.             return true;
  333.         }catch(Exception e){
  334.             logExceptionStackTrace(e);
  335.             throw new UtilsRuntimeException(e.toString(),e);
  336.         }
  337.     }

  339.     
  340.     
  341.     
  342.     
  343.     
  344.     
  345.     
  346.     /* ********** WRITE TO ********* */
  347.     
  348.     public void writeTo(OutputStream out) throws UtilsException{
  349.         this.writeTo(out, WriteToSerializerType.XML_JAXB);
  350.     }
  351.     public void writeTo(OutputStream out,WriteToSerializerType type) throws UtilsException{
  352.         this.writeToEngine(out, type, null);
  353.     }
  354.     public void writeTo(OutputStream out,WriteToSerializerType type, boolean pretty) throws UtilsException{
  355.         this.writeToEngine(out, type, pretty);
  356.     }
  357.     private void writeToEngine(OutputStream out,WriteToSerializerType type, Boolean pretty) throws UtilsException{
  358.         try{
  359.             switch (type) {
  360.                 case XML_JAXB:
  361.                     boolean xmlPretty = true;  /** backward compatibility;*/
  362.                     if(pretty!=null) { 
  363.                         xmlPretty = pretty.booleanValue();
  364.                     }
  365.                     JaxbUtils.objToXml(out, getClass(), this, xmlPretty);
  366.                     break;
  367.                 case JSON_JACKSON:
  368.                     SerializationConfig config = new SerializationConfig();
  369.                     if(pretty!=null) {
  370.                         config.setPrettyPrint(pretty.booleanValue());
  371.                     }
  372.                     ISerializer jsonJacksonSerializer = SerializationFactory.getSerializer(SERIALIZATION_TYPE.JSON_JACKSON, config);
  373.                     jsonJacksonSerializer.writeObject(this, out);
  374.                     break;
  375.                 case JAVA:
  376.                     JavaSerializer javaSerializer = new JavaSerializer();
  377.                     javaSerializer.writeObject(this, out);
  378.                     break;
  379.             }
  380.         }catch(Exception e){
  381.             throw new UtilsException(e.getMessage(), e);
  382.         }
  383.     }
  384.     
  385.     
  386.     
  387.     
  388.     
  389.     /* ********** serialize ********* */
  390.     
  391.     public String toXml() throws UtilsException{
  392.         return this.serialize(WriteToSerializerType.XML_JAXB);
  393.     }
  394.     public String toJson() throws UtilsException{
  395.         return this.serialize(WriteToSerializerType.JSON_JACKSON);
  396.     }
  397.     // Non è utile. Al massimo si usa sopra come writeTo
  398.     /**public String toJava() throws UtilsException{
  399.         return this.serialize(WriteToSerializerType.JAVA);
  400.     }*/
  401.     public String serialize(WriteToSerializerType type) throws UtilsException{
  402.         ByteArrayOutputStream bout = new ByteArrayOutputStream();
  403.         this.writeTo(bout, type);
  404.         return bout.toString();
  405.     }
  406.     
  407.     
  408.     
  409.     
  410.     
  411.     
  412.     
  413.     
  414.     /* ********** TO STRING ********* */
  415.     
  416.     private static ToStringStyle defaultToStringStyle =  ToStringStyle.MULTI_LINE_STYLE;
  417.     private static boolean defaultToStringOutputTransients =  false;
  418.     private static boolean defaultToStringOutputStatics =  false;
  419.     public static void setDefaultStyleToString(ToStringStyle style,boolean outputTransients,boolean outputStatics){
  420.         // Il default statico serve per impostare uno "stile" che viene ereditato da tutti gli oggetti che estendono il base bean.
  421.         // In questa maniera gli oggetti interni all'oggetto stesso vengono serializzati con lo stile impostato.
  422.         defaultToStringStyle = style;
  423.         defaultToStringOutputTransients = outputTransients;
  424.         defaultToStringOutputStatics = outputStatics;
  425.     }
  426.     @Override
  427.     public String toString(){
  428.         return this.toString(defaultToStringStyle, defaultToStringOutputTransients, defaultToStringOutputStatics, null);
  429.     }
  430.     public String toString(ToStringStyle style){
  431.         return this.toString(style, false, false, null);
  432.     }
  433.     public String toString(ToStringStyle style,boolean outputTransients,boolean outputStatics){
  434.         return this.toString(style, outputTransients, outputStatics, null);
  435.     }
  436.     public String toString(ToStringStyle style,boolean outputTransients,boolean outputStatics,Class<?>reflectUpToClass){
  437.         StringBuilder buffer = new StringBuilder();
  438.         this.toString(style, buffer, outputTransients, outputStatics, reflectUpToClass);
  439.         return buffer.toString();
  440.     }
  441.     public void toString(ToStringStyle style,StringBuilder buffer,boolean outputTransients,boolean outputStatics){
  442.         this.toString(style, buffer, outputTransients, outputStatics, null);
  443.     }
  444.     public void toString(ToStringStyle style,StringBuilder buffer,boolean outputTransients,boolean outputStatics,Class<?>reflectUpToClass){
  445.         StringBuffer bf = new StringBuffer();
  446.         ReflectionToStringBuilder builder = new ReflectionToStringBuilder(this, style, bf, reflectUpToClass, outputTransients, outputStatics);
  447.         builder.toString();
  448.         buffer.append(bf.toString());
  449.     }
  450.     
  451.     
  452.     // Old Method
  453.     public String toString_oldMethod(){
  454.         return toStringEngine(false, null);
  455.     }
  456.     public String toString(boolean reportHTML){
  457.         return toStringEngine(reportHTML,null);
  458.     }
  459.     public String toString(List<String> fieldsNotIncluded){
  460.         return toStringEngine(false,fieldsNotIncluded);
  461.     }
  462.     public String toString(boolean reportHTML,boolean includeLongId){
  463.         List<String> fieldsNotIncluded = new ArrayList<>();
  464.         if(!includeLongId){
  465.             fieldsNotIncluded.add("id");
  466.         }
  467.         return toStringEngine(reportHTML,fieldsNotIncluded);
  468.     }
  469.     public String toString(boolean reportHTML,List<String> fieldsNotIncluded){
  470.         return toStringEngine(reportHTML,fieldsNotIncluded);
  471.     }
  472.     private String toStringEngine(boolean reportHTML,List<String> fieldsNotIncluded){   
  473.         try{
  474.             StringBuilder bf = new StringBuilder();
  475.             java.lang.reflect.Field[] fields = getClass().getDeclaredFields();
  476.             for(int i=0; i<fields.length;i++){
  477.             
  478.                 /**System.out.println("["+fields[i].getName()+"]");*/
  479.                 if(java.lang.reflect.Modifier.isStatic(fields[i].getModifiers())){
  480.                     /**System.out.println("IS STATIC");*/
  481.                     continue;
  482.                 }
  483.                 
  484.                 if(fields[i].getType().isAssignableFrom(org.openspcoop2.utils.jaxb.DecimalWrapper.class)){
  485.                     continue;
  486.                 }
  487.                 
  488.                 // field id non controllato se in fieldsNotCheckList
  489.                 boolean ignoreField = false;
  490.                 if(fieldsNotIncluded!=null && !fieldsNotIncluded.isEmpty()){
  491.                     for (String fieldName : fieldsNotIncluded) {
  492.                         if(fieldName.equals(fields[i].getName())){
  493.                             ignoreField = true;
  494.                             break;
  495.                         }
  496.                     }
  497.                 }
  498.                 if(ignoreField){
  499.                     continue;
  500.                 }

  502.                 bf.append("---------- ");
  503.                 bf.append(this.getClass().getName());
  504.                 bf.append(".");
  505.                 bf.append(fields[i].getName());
  506.                 bf.append(" ----------");
  507.                 if(reportHTML) bf.append("<br>"); else bf.append("\n");
  508.                 
  509.                 Object fieldValue = this.getFieldValue(fields[i].getName(),this);
  510.                 /**System.out.println("LETTO VALORE["+fieldValue+"]");*/
  511.                 
  512.                 if(fieldValue==null){
  513.                     bf.append("null");
  514.                 }else{
  515.                     if(fields[i].getType().isAssignableFrom(java.util.ArrayList.class) || fields[i].getType().isAssignableFrom(java.util.List.class)){
  516.                         java.util.List<?> listaThis = (java.util.List<?>) fieldValue;
  517.                         bf.append("List size("+listaThis.size()+")");
  518.                         if(!listaThis.isEmpty()){
  519.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  520.                         }
  521.                         java.util.List<String> sortLISTKEY = new java.util.ArrayList<>();
  522.                         for(int j=0; j<listaThis.size(); j++){
  523.                             String key = null;
  524.                             if(listaThis.get(j).getClass().getName().startsWith(this.getClass().getPackage().getName())){
  525.                                 Class<?> c =  listaThis.get(j).getClass();
  526.                                 java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class,List.class);
  527.                                 key = (String) method.invoke(listaThis.get(j),reportHTML,fieldsNotIncluded);
  528.                             }else{
  529.                                 key =  listaThis.get(j).toString();
  530.                             }
  531.                             sortLISTKEY.add(key);
  532.                         }
  533.                         java.util.Collections.sort(sortLISTKEY);
  534.                         for(int j=0; j<sortLISTKEY.size(); j++){
  535.                             String key = sortLISTKEY.get(j);
  536.                             bf.append("---------- ");
  537.                             bf.append(this.getClass().getName());
  538.                             bf.append(".");
  539.                             bf.append(fields[i].getName());
  540.                             bf.append("[");
  541.                             bf.append(j);
  542.                             bf.append("] ----------");
  543.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  544.                             bf.append(key);
  545.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  546.                             bf.append("----end--- ");
  547.                             bf.append(this.getClass().getName());
  548.                             bf.append(".");
  549.                             bf.append(fields[i].getName());
  550.                             bf.append("[");
  551.                             bf.append(j);
  552.                             bf.append("] ----end---");
  553.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  554.                         }
  555.                     }else{
  556.                         if(fieldValue.getClass().getName().startsWith(this.getClass().getPackage().getName())){
  557.                             Class<?> c =  fieldValue.getClass();
  558.                             java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class,List.class);
  559.                             bf.append(method.invoke(fieldValue,reportHTML,fieldsNotIncluded));
  560.                         }else{
  561.                             if(fields[i].getType().isAssignableFrom(byte[].class)){
  562.                                 byte[] array = (byte[])fieldValue;
  563.                                 for(int k=0; k<array.length;k++){
  564.                                     bf.append(((char)array[k]));
  565.                                 }
  566.                             }else if(fields[i].getType().isAssignableFrom(java.util.Date.class)){
  567.                                 java.util.Date date = (java.util.Date) fieldValue;
  568.                                 bf.append(DateUtils.getSimpleDateFormatMs().format(date));
  569.                             }else{
  570.                                 bf.append(fieldValue.toString());
  571.                             }
  572.                         }
  573.                     }
  574.                 }
  575.                 if(reportHTML) bf.append("<br>"); else bf.append("\n");
  576.                 bf.append("---end---- ");
  577.                 bf.append(this.getClass().getName());
  578.                 bf.append(".");
  579.                 bf.append(fields[i].getName());
  580.                 bf.append(" ---end----");
  581.                 if(reportHTML) bf.append("<br>"); else bf.append("\n");
  582.             }
  583.             return bf.toString();
  584.         }catch(Exception e){
  585.             logExceptionStackTrace(e);
  586.             throw new UtilsRuntimeException(e.toString(),e);
  587.         }
  588.     }

  590.     
  591.     
  592.     
  593.     
  594.     
  595.     /* ********** DIFF ********* */
  596.     
  597.     public String diff(Object object,StringBuilder bf){
  598.         return diffEngine(object,bf,false, null);
  599.     }
  600.     public String diff(Object object,StringBuilder bf,boolean reportHTML){
  601.         return diffEngine(object,bf,reportHTML,null);
  602.     }
  603.     public String diff(Object object,StringBuilder bf,List<String> fieldsNotIncluded){
  604.         return diffEngine(object,bf,false,fieldsNotIncluded);
  605.     }
  606.     public String diff(Object object,StringBuilder bf,boolean reportHTML,boolean includeLongId){
  607.         List<String> fieldsNotIncluded = new ArrayList<>();
  608.         if(!includeLongId){
  609.             fieldsNotIncluded.add("id");
  610.         }
  611.         return diffEngine(object,bf,reportHTML,fieldsNotIncluded);
  612.     }
  613.     public String diff(Object object,StringBuilder bf,boolean reportHTML,List<String> fieldsNotIncluded){
  614.         return diffEngine(object,bf,reportHTML,fieldsNotIncluded);
  615.     }
  616.     @SuppressWarnings("unchecked")
  617.     private String diffEngine(Object object,StringBuilder bf,boolean reportHTML,List<String> fieldsNotIncluded){    
  618.     
  619.         try{
  620.             if(object==null){
  621.                 bf.append(this.getClass().getName());
  622.                 bf.append("this is not null, parameter is null");
  623.                 return bf.toString();
  624.             }
  625.             java.lang.reflect.Field[] fields = getClass().getDeclaredFields();
  626.             for(int i=0; i<fields.length;i++){
  627.                 
  628.                 /**System.out.println("["+fields[i].getName()+"]");*/
  629.                 if(java.lang.reflect.Modifier.isStatic(fields[i].getModifiers())){
  630.                     /**System.out.println("IS STATIC");*/
  631.                     continue;
  632.                 }
  633.                 
  634.                 if(fields[i].getType().isAssignableFrom(org.openspcoop2.utils.jaxb.DecimalWrapper.class)){
  635.                     continue;
  636.                 }
  637.                 
  638.                 Object fieldValueThis = this.getFieldValue(fields[i].getName(),this);
  639.                 Object fieldValueObject = this.getFieldValue(fields[i].getName(),object);
  640.                 
  641.                 if(fields[i].getType().isAssignableFrom(java.util.ArrayList.class) || fields[i].getType().isAssignableFrom(java.util.List.class)){
  642.                     // LISTA
  643.                     java.util.List<?> listaThis = (java.util.List<?>) fieldValueThis;
  644.                     java.util.List<?> listaParameter = (java.util.List<?>) fieldValueObject;
  645.                     if(listaThis==null){
  646.                         // this_list is null, parameter list is not null
  647.                         if(listaParameter!=null){
  648.                             bf.append(this.getClass().getName());
  649.                             bf.append(".");
  650.                             bf.append(fields[i].getName());
  651.                             bf.append(" this_list:is null, parameter_list: is not null");
  652.                             bf.append(" ,parameter_list_size:"+listaParameter.size());
  653.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  654.                         }
  655.                     }else{
  656.                         // this_list is not null, parameter list is null
  657.                         if(listaParameter==null){
  658.                             bf.append(this.getClass().getName());
  659.                             bf.append(".");
  660.                             bf.append(fields[i].getName());
  661.                             bf.append(" this_list: is not null, parameter_list: is null");
  662.                             bf.append(" ,this_list_size:"+listaThis.size());
  663.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  664.                         }
  665.                         // this_list different size from parameter_list
  666.                         else if(listaThis.size() != listaParameter.size()){
  667.                             bf.append(this.getClass().getName());
  668.                             bf.append(".");
  669.                             bf.append(fields[i].getName());
  670.                             bf.append(" this_list_size:"+listaThis.size()+", parameter_list_size:"+listaParameter.size());
  671.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  672.                         }
  673.                         // Controllo elementi della lista
  674.                         else{
  675.                             // SORT
  676.                             java.util.List<Object> listaThisSORT = new java.util.ArrayList<>();
  677.                             java.util.List<Object> listaParameterSORT = new java.util.ArrayList<>();
  678.                             boolean listaNonCompleta = false;
  679.                             try{
  680.                                 java.util.List<String> listaThisTMP = new java.util.ArrayList<>();
  681.                                 java.util.Map<String, Object> thisTmp = new java.util.HashMap<>();
  682.                                 java.util.Map<String, Object> parameterTmp = new java.util.HashMap<>();
  683.                                 for(int k=0; k<listaThis.size(); k++){
  684.                                     Object thisObject = listaThis.get(k);
  685.                                     Object paramObject = listaParameter.get(k);
  686.                                     if(thisObject==null && paramObject!=null)
  687.                                         throw new UtilsException("DIFF");
  688.                                     if(thisObject!=null && paramObject==null)
  689.                                         throw new UtilsException("DIFF");
  690.                                     if(thisObject!=null && paramObject!=null){
  691.                                         // THIS
  692.                                         String key = null;
  693.                                         if(thisObject.getClass().getName().startsWith(this.getClass().getPackage().getName())){
  694.                                             Class<?> c =  thisObject.getClass();
  695.                                             java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class,boolean.class);
  696.                                             key = (String) method.invoke(thisObject,false,true);
  697.                                         }else{
  698.                                             key = thisObject.toString();
  699.                                         }
  700.                                         thisTmp.put(key, thisObject);
  701.                                         listaThisTMP.add(key);

  703.                                         // PARAM
  704.                                         if(paramObject.getClass().getName().startsWith(this.getClass().getPackage().getName())){
  705.                                             Class<?> c =  paramObject.getClass();
  706.                                             java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class,boolean.class);
  707.                                             key = (String) method.invoke(paramObject,false,true);
  708.                                         }else{
  709.                                             key = paramObject.toString();
  710.                                         }
  711.                                         parameterTmp.put(key, paramObject);
  712.                                     }
  713.                                 }
  714.                                 java.util.Collections.sort(listaThisTMP);
  715.                                 for(int k=0; k<listaThisTMP.size(); k++){
  716.                                     String key = listaThisTMP.get(k);
  717.                                     Object thisObject = thisTmp.get(key);
  718.                                     Object paramObject = parameterTmp.get(key);
  719.                                     if(thisObject==null){
  720.                                         // significa che manca un elemento
  721.                                         listaThisSORT = (java.util.List<Object>) listaThis;
  722.                                         listaParameterSORT = (java.util.List<Object>) listaParameter;
  723.                                         bf.append("["+this.getClass().getName());
  724.                                         bf.append(".");
  725.                                         bf.append(fields[i].getName()+"] ");
  726.                                         bf.append("Match non trovato in this(size:"+thisTmp.size()+") per l'elemento: "+key);
  727.                                         if(!thisTmp.isEmpty()) {
  728.                                             int j=0;
  729.                                             for (String keyJ : thisTmp.keySet()) {
  730.                                                 bf.append("ELEMENTO_THIS_["+j+"]=["+keyJ+"]");
  731.                                                 j++;
  732.                                             }
  733.                                         }
  734.                                         listaNonCompleta = true;
  735.                                         break;
  736.                                     }
  737.                                     if(paramObject==null){
  738.                                         // significa che manca un elemento
  739.                                         listaThisSORT = (java.util.List<Object>) listaThis;
  740.                                         listaParameterSORT = (java.util.List<Object>) listaParameter;
  741.                                         bf.append("["+this.getClass().getName());
  742.                                         bf.append(".");
  743.                                         bf.append(fields[i].getName()+"] ");
  744.                                         bf.append("Match non trovato in param(size:"+parameterTmp.size()+") per l'elemento: "+key);
  745.                                         if(!parameterTmp.isEmpty()) {
  746.                                             int j=0;
  747.                                             for (String keyJ : parameterTmp.keySet()) {
  748.                                                 bf.append("ELEMENTO_PARAM_["+j+"]=["+keyJ+"]");
  749.                                                 j++;
  750.                                             }
  751.                                         }
  752.                                         listaNonCompleta = true;
  753.                                         break;
  754.                                     }
  755.                                     listaThisSORT.add(thisObject);
  756.                                     listaParameterSORT.add(paramObject);
  757.                                 }
  758.                             }
  759.                             catch(RuntimeException e){
  760.                                 // By SpotBugs
  761.                                 listaParameterSORT = (java.util.List<Object>) listaParameter;
  762.                                 listaThisSORT = (java.util.List<Object>) listaThis;
  763.                             }
  764.                             catch(Exception e){
  765.                                 listaThisSORT = (java.util.List<Object>) listaThis;
  766.                                 listaParameterSORT = (java.util.List<Object>) listaParameter;
  767.                             }
  768.                             if(!listaNonCompleta){
  769.                                 for(int j=0; j<listaThisSORT.size(); j++){
  770.                                     if(listaThisSORT.get(j)==null){
  771.                                         bf.append(this.getClass().getName());
  772.                                         bf.append(".");
  773.                                         bf.append(fields[i].getName()+"["+j+"]");
  774.                                         bf.append(" this_list: is null, parameter: is not null");
  775.                                         bf.append(" parameter_value:");
  776.                                         if(reportHTML) bf.append("<br>"); else bf.append("\n");
  777.                                         if(listaParameterSORT.get(j).getClass().getName().startsWith(this.getClass().getPackage().getName())){
  778.                                             Class<?> c =  listaParameterSORT.get(j).getClass();
  779.                                             java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class);
  780.                                             bf.append(method.invoke(listaParameterSORT.get(j),reportHTML));
  781.                                         }else{
  782.                                             bf.append(listaParameterSORT.get(j).toString());
  783.                                         }
  784.                                         if(reportHTML) bf.append("<br>"); else bf.append("\n");
  785.                                     }else{
  786.                                         if(listaThisSORT.get(j).getClass().getName().startsWith(this.getClass().getPackage().getName())){
  787.                                             Class<?> c =  listaThisSORT.get(j).getClass();
  788.                                             java.lang.reflect.Method method =  c.getMethod("diff",Object.class,bf.getClass(),boolean.class,List.class);
  789.                                             method.invoke(listaThisSORT.get(j),listaParameterSORT.get(j),bf,reportHTML,fieldsNotIncluded);
  790.                                         }else{
  791.                                             boolean checkUguaglianza = false;
  792.                                             if(listaThisSORT.get(j).getClass().isAssignableFrom(byte[].class)){
  793.                                                 if(listaParameterSORT.get(j)!=null){
  794.                                                     byte[] origi = (byte[]) listaThisSORT.get(j);
  795.                                                     byte[] dest = (byte[]) listaParameterSORT.get(j);
  796.                                                     checkUguaglianza = (origi.length == dest.length);
  797.                                                     if(checkUguaglianza){
  798.                                                         for(int k=0;k<origi.length;k++){
  799.                                                             if(origi[k]!=dest[k]){
  800.                                                                 checkUguaglianza = false;
  801.                                                                 break;
  802.                                                             }
  803.                                                         }
  804.                                                     }
  805.                                                 }
  806.                                             }else{
  807.                                                 checkUguaglianza = listaThisSORT.get(j).equals(listaParameterSORT.get(j));
  808.                                             }
  809.                                             if(!checkUguaglianza){
  810.                                                 bf.append(this.getClass().getName());
  811.                                                 bf.append(".");
  812.                                                 bf.append(fields[i].getName()+"["+j+"]");
  813.                                                 
  814.                                                 bf.append(" this:");
  815.                                                 if(listaThisSORT.get(j).getClass().isAssignableFrom(byte[].class)){
  816.                                                     if(listaThisSORT.get(j)!=null){
  817.                                                         byte[] array = (byte[])listaThisSORT.get(j);
  818.                                                         for(int k=0; k<array.length;k++)
  819.                                                             bf.append(((char)array[k]));
  820.                                                     }
  821.                                                     else
  822.                                                         bf.append("null");
  823.                                                 }else if(listaThisSORT.get(j).getClass().isAssignableFrom(java.util.Date.class)){
  824.                                                     if(listaThisSORT.get(j)!=null){
  825.                                                         java.util.Date date = (java.util.Date) listaThisSORT.get(j);
  826.                                                         bf.append(DateUtils.getSimpleDateFormatMs().format(date));
  827.                                                     }
  828.                                                     else
  829.                                                         bf.append("null");
  830.                                                 }else{
  831.                                                     bf.append(listaThisSORT.get(j));
  832.                                                 }
  833.                                                 
  834.                                                 bf.append(" parameter:");
  835.                                                 if(listaParameterSORT.get(j).getClass().isAssignableFrom(byte[].class)){
  836.                                                     if(listaParameterSORT.get(j)!=null){
  837.                                                         byte[] array = (byte[])listaParameterSORT.get(j);
  838.                                                         for(int k=0; k<array.length;k++)
  839.                                                             bf.append(((char)array[k]));
  840.                                                     }
  841.                                                     else
  842.                                                         bf.append("null");
  843.                                                 }else if(listaParameterSORT.get(j).getClass().isAssignableFrom(java.util.Date.class)){
  844.                                                     if(listaParameterSORT.get(j)!=null){
  845.                                                         java.util.Date date = (java.util.Date) listaParameterSORT.get(j);
  846.                                                         bf.append(DateUtils.getSimpleDateFormatMs().format(date));
  847.                                                     }
  848.                                                     else
  849.                                                         bf.append("null");
  850.                                                 }else{
  851.                                                     bf.append(listaParameterSORT.get(j));
  852.                                                 }
  853.                                                 if(reportHTML) bf.append("<br>"); else bf.append("\n");
  854.                                             }
  855.                                         }
  856.                                     }
  857.                                 }
  858.                             }
  859.                         }
  860.                     }
  861.                 }
  862.                 else{
  863.                     // field id non controllato se in fieldsNotCheckList
  864.                     boolean ignoreField = false;
  865.                     if(fieldsNotIncluded!=null && !fieldsNotIncluded.isEmpty()){
  866.                         for (String fieldName : fieldsNotIncluded) {
  867.                             if(fieldName.equals(fields[i].getName())){
  868.                                 ignoreField = true;
  869.                                 break;
  870.                             }
  871.                         }
  872.                     }
  873.                     if(ignoreField){
  874.                         continue;
  875.                     }

  877.                     // ELEMENTO SINGOLO
  878.                     if(fieldValueThis==null){
  879.                         // this is null, parameter is not null
  880.                         if(fieldValueObject!=null){
  881.                             bf.append(this.getClass().getName());
  882.                             bf.append(".");
  883.                             bf.append(fields[i].getName());
  884.                             bf.append(" this:is null, parameter: is not null");
  885.                             bf.append(" parameter_value:");
  886.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  887.                             if(fieldValueObject.getClass().getName().startsWith(this.getClass().getPackage().getName())){
  888.                                 Class<?> c =  fieldValueObject.getClass();
  889.                                 java.lang.reflect.Method method =  c.getMethod(TO_STRING_METHOD,boolean.class);
  890.                                 bf.append(method.invoke(fieldValueObject,reportHTML));
  891.                             }else{
  892.                                 if(fields[i].getType().isAssignableFrom(byte[].class)){
  893.                                     byte[] array = (byte[])fieldValueObject;
  894.                                     for(int k=0; k<array.length;k++)
  895.                                         bf.append(array[k]);
  896.                                 }else if(fields[i].getType().isAssignableFrom(java.util.Date.class)){
  897.                                     java.util.Date date = (java.util.Date) fieldValueObject;
  898.                                     bf.append(DateUtils.getSimpleDateFormatMs().format(date));
  899.                                 }else{
  900.                                     bf.append(fieldValueObject);
  901.                                 }
  902.                             }
  903.                             if(reportHTML) bf.append("<br>"); else bf.append("\n");
  904.                         }
  905.                     }else{
  906.                         if(fields[i].getType().getName().startsWith(this.getClass().getPackage().getName())){
  907.                             java.lang.reflect.Method method =  fields[i].getType().getMethod("diff",Object.class,bf.getClass(),boolean.class,List.class);
  908.                             method.invoke(fieldValueThis,fieldValueObject,bf,reportHTML,fieldsNotIncluded);
  909.                         }else{
  910.                             boolean checkUguaglianza = false;
  911.                             if(fields[i].getType().isAssignableFrom(byte[].class)){
  912.                                 if(fieldValueObject!=null){
  913.                                     byte[] origi = (byte[]) fieldValueThis;
  914.                                     byte[] dest = (byte[]) fieldValueObject;
  915.                                     checkUguaglianza = (origi.length == dest.length);
  916.                                     if(checkUguaglianza){
  917.                                         for(int k=0;k<origi.length;k++){
  918.                                             if(origi[k]!=dest[k]){
  919.                                                 checkUguaglianza = false;
  920.                                                 break;
  921.                                             }
  922.                                         }
  923.                                     }
  924.                                 }
  925.                             }else{
  926.                                 if(fields[i].getType().isAssignableFrom(java.util.Date.class)){
  927.                                     if(fieldValueObject!=null){
  928.                                         java.util.Calendar calendarThis = new java.util.GregorianCalendar();
  929.                                         calendarThis.setTime((java.util.Date)fieldValueThis);
  930.                                         java.util.Calendar calendarObject = new java.util.GregorianCalendar();
  931.                                         calendarObject.setTime((java.util.Date)fieldValueObject);
  932.                                         checkUguaglianza = (  calendarThis.get(java.util.Calendar.YEAR) == calendarObject.get(java.util.Calendar.YEAR) ) && 
  933.                                                 ( calendarThis.get(java.util.Calendar.MONTH) == calendarObject.get(java.util.Calendar.MONTH) ) && 
  934.                                                 ( calendarThis.get(java.util.Calendar.DAY_OF_MONTH) == calendarObject.get(java.util.Calendar.DAY_OF_MONTH) ) && 
  935.                                                 ( calendarThis.get(java.util.Calendar.HOUR_OF_DAY) == calendarObject.get(java.util.Calendar.HOUR_OF_DAY) ) && 
  936.                                                 ( calendarThis.get(java.util.Calendar.MINUTE) == calendarObject.get(java.util.Calendar.MINUTE) ) && 
  937.                                                 ( calendarThis.get(java.util.Calendar.SECOND) == calendarObject.get(java.util.Calendar.SECOND) ) && 
  938.                                                 ( calendarThis.get(java.util.Calendar.MILLISECOND) == calendarObject.get(java.util.Calendar.MILLISECOND) );
  939.                                     }
  940.                                 }else{
  941.                                     checkUguaglianza = fieldValueThis.equals(fieldValueObject);
  942.                                 }
  943.                             }
  944.                             if(!checkUguaglianza){
  945.                                 bf.append(this.getClass().getName());
  946.                                 bf.append(".");
  947.                                 bf.append(fields[i].getName());
  948.                                 
  949.                                 bf.append(" this:");
  950.                                 if(fields[i].getType().isAssignableFrom(byte[].class)){
  951.                                     byte[] array = (byte[])fieldValueThis;
  952.                                     for(int k=0; k<array.length;k++)
  953.                                         bf.append(((char)array[k]));
  954.                                 }else if(fields[i].getType().isAssignableFrom(java.util.Date.class)){
  955.                                     java.util.Date date = (java.util.Date) fieldValueThis;
  956.                                     bf.append(DateUtils.getSimpleDateFormatMs().format(date));
  957.                                 }else{
  958.                                     bf.append(fieldValueThis);
  959.                                 }
  960.                                 
  961.                                 bf.append(" parameter:");
  962.                                 if(fields[i].getType().isAssignableFrom(byte[].class)){
  963.                                     if(fieldValueObject!=null){
  964.                                         byte[] array = (byte[])fieldValueObject;
  965.                                         for(int k=0; k<array.length;k++)
  966.                                             bf.append(((char)array[k]));
  967.                                     }
  968.                                     else
  969.                                         bf.append("null");
  970.                                 }else if(fields[i].getType().isAssignableFrom(java.util.Date.class)){
  971.                                     if(fieldValueObject!=null){
  972.                                         java.util.Date date = (java.util.Date) fieldValueObject;
  973.                                         bf.append(DateUtils.getSimpleDateFormatMs().format(date));
  974.                                     }else
  975.                                         bf.append("null");
  976.                                 }else{
  977.                                     bf.append(fieldValueObject);
  978.                                 }
  979.                                 if(reportHTML) bf.append("<br>"); else bf.append("\n");
  980.                             }
  981.                         }
  982.                     }
  983.                 }
  984.             }
  985.             return bf.toString();
  986.         }catch(Exception e){
  987.             logExceptionStackTrace(e);
  988.             throw new UtilsRuntimeException(e.toString(),e);
  989.         }
  990.     }

  992.     
  993.     
  994.     
  995.     
  996.     
  997.     
  998.     
  999.     
  1000.     /* ********** CLONE ********* */
  1001.     
  1002.     @Override
  1003.     public Object clone()  {
  1004.         Object clone = null;
  1005.         try{
  1006.             //clono l'oggetto
  1007.             clone = super.clone();
  1008.             //clone = this.getClass().newInstance(); NON FUNZIONA NON VENGONO COPIATI I VARI FIELDS
  1009.             /*
  1010.              * Per ogni field se il field presente nella classe implementa
  1011.              * l'interfaccia cloneable allora eseguo il metodo clone di quel field
  1012.              */
  1013.             java.lang.reflect.Field[] fields = this.getClass().getDeclaredFields();
  1014.             if(fields!=null && fields.length>0){
  1015.                 for (int i = 0; i < fields.length; i++) {
  1016.                     
  1017.                     /**System.out.println("["+fields[i].getName()+"]");*/
  1018.                     if(java.lang.reflect.Modifier.isStatic(fields[i].getModifiers())){
  1019.                         /**System.out.println("IS STATIC");*/
  1020.                         continue;
  1021.                     }
  1022.                     
  1023.                     if(fields[i].getType().isAssignableFrom(org.openspcoop2.utils.jaxb.DecimalWrapper.class)){
  1024.                         continue;
  1025.                     }
  1026.                     
  1027.                     
  1028.                     java.lang.reflect.Field field = fields[i];
  1029.                     Object fieldValue = this.getFieldValue(field.getName(), this);
  1030.                     if(fieldValue==null){
  1031.                         continue;
  1032.                     }
  1033.                     
  1034.                     /**System.out.println("ESAMINO FIELD ["+field.getName()+"] type["+field.getType().getName()+"] isEnum["+(field.getType().isEnum())+"]");*/
  1035.                     
  1036.                     if(field.getType().isAssignableFrom(byte[].class)){
  1037.                         //caso particolare arrya di byte
  1038.                         byte[] originale = (byte[]) fieldValue;
  1039.                         if(originale!=null){
  1040.                             byte[] arrayClone = new byte[originale.length];
  1041.                             for (int j = 0; j < arrayClone.length; j++) {
  1042.                                 arrayClone[j]=originale[j];
  1043.                             }
  1044.                             this.setFieldValue(field.getName(), clone, field.getType(), arrayClone);
  1045.                         }
  1046.                     }
  1047.                     else if(field.getType().isEnum()){
  1048.                         // Imposto nel nuovo oggetto il valore dell'enum
  1049.                         //setto il field clonato nel clone
  1050.                         this.setFieldValue(field.getName(), clone, field.getType(), fieldValue);
  1051.                     }
  1052.                     else if(isSupportedCloneList(field)){
  1053.                         List<?> listOriginale = (List<?>) fieldValue;
  1054.                         if(listOriginale!=null){
  1055.                             List<?> listClone  = this.cloneList(listOriginale);
  1056.                             //setto il field clonato nel clone
  1057.                             this.setFieldValue(field.getName(), clone, field.getType(), listClone);
  1058.                         }
  1059.                     }
  1060.                     else {
  1061.                         //recupero interfacce implementate da questo field
  1062.                         Class<?>[] interfacce = field.getType().getInterfaces();
  1063.                         for (int j = 0; j < interfacce.length; j++) {
  1064.                             //se il field che sto controllando implementa l'interfaccia cloneable e il field che voglio clonare non e' null
  1065.                             //richiamo il clone
  1066.                             if(interfacce[j].isAssignableFrom(java.lang.Cloneable.class) && fieldValue!=null ){
  1067.                                 //recupero il metodo clone dal field
  1068.                                 java.lang.reflect.Method method =  field.getType().getMethod("clone");
  1069.                                 //effettuo il clone del field
  1070.                                 java.lang.Cloneable ris =  (java.lang.Cloneable) method.invoke(fieldValue);
  1071.                                 //setto il field clonato nel clone
  1072.                                 this.setFieldValue(field.getName(), clone, field.getType(), ris);
  1073.                             }
  1074.                         }
  1075.                     }
  1076.                 }
  1077.             }

  1079.         }catch (Exception e) {
  1080.             logExceptionStackTrace(e);
  1081.             throw new UtilsRuntimeException(e.toString(),e);
  1082.         }
  1083.         return clone;
  1084.     }

  1086.     private boolean isSupportedCloneList(java.lang.reflect.Field field){
  1087.         return field.getType().isAssignableFrom(java.util.List.class) ||
  1088.                 field.getType().isAssignableFrom(java.util.ArrayList.class)  ||
  1089.                 field.getType().isAssignableFrom(java.util.Vector.class) ||
  1090.                 field.getType().isAssignableFrom(java.util.Stack.class) ||
  1091.                 field.getType().isAssignableFrom(java.util.LinkedList.class) ||
  1092.                 field.getType().isAssignableFrom(java.util.concurrent.CopyOnWriteArrayList.class);
  1093.     }
  1094.     @SuppressWarnings({ "rawtypes", "unchecked" })
  1095.     private List cloneList(List<?> listOriginale) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException{
  1096.         List listClone  = null;
  1097.         if(listOriginale.getClass().isAssignableFrom(java.util.ArrayList.class)){
  1098.             listClone = new java.util.ArrayList<>();
  1099.         }
  1100.         else if(listOriginale.getClass().isAssignableFrom(java.util.Vector.class)){
  1101.             listClone = new java.util.Vector<>();
  1102.         }
  1103.         else if(listOriginale.getClass().isAssignableFrom(java.util.Stack.class)){
  1104.             listClone = new java.util.Stack<>();
  1105.         }
  1106.         else if(listOriginale.getClass().isAssignableFrom(java.util.LinkedList.class)){
  1107.             listClone = new java.util.LinkedList<>();
  1108.         }
  1109.         else if(listOriginale.getClass().isAssignableFrom(java.util.concurrent.CopyOnWriteArrayList.class)){
  1110.             listClone = new java.util.concurrent.CopyOnWriteArrayList<>();
  1111.         }
  1112.         if(listClone!=null){
  1113.             for (int j = 0; j < listOriginale.size(); j++) {
  1114.                 Object oOriginale = listOriginale.get(j);
  1115.                 if(oOriginale!=null){
  1116.                     if(oOriginale instanceof java.lang.Cloneable){
  1117.                         //recupero il metodo clone dal field
  1118.                         java.lang.reflect.Method method =  oOriginale.getClass().getMethod("clone");
  1119.                         //effettuo il clone del field
  1120.                         java.lang.Cloneable oCloned =  (java.lang.Cloneable) method.invoke(oOriginale);
  1121.                         //aggiungo il field clonato nella lista
  1122.                         listClone.add(oCloned);
  1123.                     }
  1124.                     else if(oOriginale instanceof String) {
  1125.                         String sOriginale = (String) oOriginale;
  1126.                         String sCloned = new String(sOriginale.toCharArray());
  1127.                         //aggiungo il field clonato nella lista
  1128.                         listClone.add(sCloned);
  1129.                     }
  1130.                 }
  1131.                 else{
  1132.                     listClone.add(null);
  1133.                 }
  1134.             }
  1135.         }
  1136.         return listClone;
  1137.     }
  1138. }
Created with JaCoCo 0.8.8.202204050719