AbstractCacheWrapper.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.  */

  21. package org.openspcoop2.utils.cache;

  23. import java.lang.reflect.Method;

  25. import org.slf4j.Logger;
  26. import org.openspcoop2.utils.SemaphoreLock;
  27. import org.openspcoop2.utils.UtilsException;

  29. /**
  30.  * AbstractCacheManager
  31.  *
  32.  * @author Poli Andrea (apoli@link.it)
  33.  * @author $Author$
  34.  * @version $Rev$, $Date$
  35.  */
  36. public abstract class AbstractCacheWrapper {

  38.     private final org.openspcoop2.utils.Semaphore lockCache = new org.openspcoop2.utils.Semaphore("AbstractCacheWrapper");
  39.     private Cache cache = null;
  40.     private Logger log = null;
  41.     private String cacheName = null;
  42.     
  43.     public AbstractCacheWrapper(CacheType cacheType, String cacheName, Logger log) throws UtilsException{
  44.         
  45.         this(cacheType, cacheName, true, log, null, null, null, null);
  46.         
  47.     }
  48.     
  49.     public AbstractCacheWrapper(CacheType cacheType, String cacheName, boolean initializeCache, Logger log) throws UtilsException{
  50.         
  51.         this(cacheType, cacheName, initializeCache, log, null, null, null, null);
  52.         
  53.     }
  54.     
  55.     public AbstractCacheWrapper(CacheType cacheType, String cacheName, Logger log,
  56.             Integer cacheSize,CacheAlgorithm cacheAlgorithm,
  57.             Integer itemIdleTimeSeconds, Integer itemLifeTimeSeconds) throws UtilsException{
  58.         
  59.         this(cacheType, cacheName, true, log, cacheSize, cacheAlgorithm, itemIdleTimeSeconds, itemLifeTimeSeconds);
  60.         
  61.     }
  62.     
  63.     private AbstractCacheWrapper(CacheType cacheType, String cacheName, boolean initializeCache, Logger log,
  64.             Integer cacheSize,CacheAlgorithm cacheAlgorithm,
  65.             Integer itemIdleTimeSeconds, Integer itemLifeTimeSeconds) throws UtilsException{
  66.         
  67.         if(cacheName==null){
  68.             throw new UtilsException("Cache name undefined");
  69.         }
  70.         this.cacheName = cacheName;
  71.         
  72.         if(log==null){
  73.             throw new UtilsException("Logger undefined");
  74.         }
  75.         this.log = log;
  76.         
  77.         if(initializeCache){
  78.             this.initCacheConfigurazione(cacheType, cacheSize, cacheAlgorithm, itemIdleTimeSeconds, itemLifeTimeSeconds);
  79.         }
  80.     }
  81.     
  82.     public String getCacheName() {
  83.         return this.cacheName;
  84.     }
  85.         
  86.     private void initCacheConfigurazione(CacheType cacheType, Integer cacheSize,CacheAlgorithm cacheAlgorithm,
  87.             Integer itemIdleTimeSeconds, Integer itemLifeTimeSeconds) throws UtilsException{
  88.         
  89.         this.cache = new Cache(cacheType, this.cacheName);
  90.         
  91.         String msg = null;
  92.         if( (cacheSize!=null) ||
  93.                 (cacheAlgorithm != null) ){
  94.          
  95.             if( cacheSize!=null ){
  96.                 int dimensione = -1;
  97.                 try{
  98.                     dimensione = cacheSize.intValue();
  99.                     msg = "Cache size ("+this.cacheName+"): "+dimensione;
  100.                     this.log.debug(msg);
  101.                     this.cache.setCacheSize(dimensione);
  102.                 }catch(Exception error){
  103.                     throw new UtilsException("Cache size parameter wrong ("+this.cacheName+"): "+error.getMessage());
  104.                 }
  105.             }
  106.             if( cacheAlgorithm != null ){
  107.                 msg = "Cache algorithm ("+this.cacheName+"): "+cacheAlgorithm.name();
  108.                 this.log.debug(msg);
  109.                 this.cache.setCacheAlgoritm(cacheAlgorithm);
  110.             }
  111.             
  112.         }
  113.         
  114.         if( (itemIdleTimeSeconds != null) ||
  115.                 (itemLifeTimeSeconds != null) ){

  117.             if( itemIdleTimeSeconds != null  ){
  118.                 int itemIdleTime = -1;
  119.                 try{
  120.                     itemIdleTime = itemIdleTimeSeconds.intValue();
  121.                     msg = "Cache 'IdleTime' attribute ("+this.cacheName+"): "+itemIdleTimeSeconds;
  122.                     this.log.debug(msg);
  123.                     this.cache.setItemIdleTime(itemIdleTime);
  124.                 }catch(Exception error){
  125.                     throw new UtilsException("Cache 'IdleTime' attribute wrong ("+this.cacheName+"): "+error.getMessage());
  126.                 }
  127.             }
  128.             if( itemLifeTimeSeconds != null  ){
  129.                 int itemLifeSecond = -1;
  130.                 try{
  131.                     itemLifeSecond = itemLifeTimeSeconds.intValue();
  132.                     msg = "Cache 'LifeTime' attribute ("+this.cacheName+"): "+itemLifeSecond;
  133.                     this.log.debug(msg);
  134.                     this.cache.setItemLifeTime(itemLifeSecond);
  135.                 }catch(Exception error){
  136.                     throw new UtilsException("Cache 'LifeTime' attribute wrong ("+this.cacheName+"): "+error.getMessage());
  137.                 }
  138.             }
  139.             
  140.         }
  141.         
  142.         this.cache.build();
  143.     }
  144.     
  145.     
  146.     
  147.     /* --------------- Cache --------------------*/
  148.     
  149.     public Logger getLog() {
  150.         return this.log;
  151.     }
  152.     
  153.     public boolean isCacheEnabled(){
  154.         return this.cache!=null;
  155.     }
  156.     
  157.     @SuppressWarnings("deprecation")
  158.     @Deprecated
  159.     public void disableSyncronizedGet() throws UtilsException {
  160.         if(this.cache==null) {
  161.             throw new UtilsException("Cache disabled");
  162.         }
  163.         this.cache.disableSyncronizedGet();
  164.     }
  165.     @SuppressWarnings("deprecation")
  166.     @Deprecated
  167.     public boolean isDisableSyncronizedGet() throws UtilsException {
  168.         if(this.cache==null) {
  169.             throw new UtilsException("Cache disabled");
  170.         }
  171.         return this.cache.isDisableSyncronizedGet();
  172.     }
  173.     
  174.     public void resetCache() throws UtilsException{
  175.         if(this.cache!=null){
  176.             try{
  177.                 this.cache.clear();
  178.             }catch(Exception e){
  179.                 throw new UtilsException(e.getMessage(),e);
  180.             }
  181.         }
  182.     }
  183.     public String printStatsCache(String separator) throws UtilsException{
  184.         if(this.cache!=null){
  185.             try{
  186.                 return this.cache.printStats(separator);
  187.             }catch(Exception e){
  188.                 throw new UtilsException(e.getMessage(),e);
  189.             }
  190.         }else{
  191.             throw new UtilsException("Cache disabled");
  192.         }
  193.     }
  194.     public void enableCache() throws UtilsException{
  195.         if(this.cache!=null)
  196.             throw new UtilsException("Cache already enabled");
  197.         else{
  198.             try{
  199.                 this.cache = new Cache(CacheType.JCS, this.cacheName); // lascio JCS come default abilitato via jmx
  200.             }catch(Exception e){
  201.                 throw new UtilsException(e.getMessage(),e);
  202.             }
  203.         }
  204.     }
  205.     public void enableCache(Integer cacheSize,Boolean cacheAlgorithmLRU,Integer itemIdleTimeSeconds,Integer itemLifeTimeSeconds) throws UtilsException{
  206.         
  207.         CacheAlgorithm cacheAlgorithm = null;
  208.         if(cacheAlgorithmLRU!=null){
  209.             if(cacheAlgorithmLRU){
  210.                 cacheAlgorithm = CacheAlgorithm.LRU;
  211.             }
  212.             else{
  213.                 cacheAlgorithm = CacheAlgorithm.MRU;
  214.             }
  215.         }
  216.         
  217.         this.enableCache(cacheSize, cacheAlgorithm, itemIdleTimeSeconds, itemLifeTimeSeconds);
  218.         
  219.     }
  220.     public void enableCache(Integer cacheSize,CacheAlgorithm cacheAlgorithm,Integer itemIdleTimeSeconds,Integer itemLifeTimeSeconds) throws UtilsException{
  221.         if(this.cache!=null)
  222.             throw new UtilsException("Cache already enabled");
  223.         else{
  224.             try{
  225.                 initCacheConfigurazione(CacheType.JCS, cacheSize, cacheAlgorithm, itemIdleTimeSeconds, itemLifeTimeSeconds); // lascio JCS come default abilitato via jmx
  226.             }catch(Exception e){
  227.                 throw new UtilsException(e.getMessage(),e);
  228.             }
  229.         }
  230.     }
  231.     public void disableCache() throws UtilsException{
  232.         if(this.cache==null)
  233.             throw new UtilsException("Cache already disabled");
  234.         else{
  235.             try{
  236.                 this.cache.clear();
  237.                 this.cache = null;
  238.             }catch(Exception e){
  239.                 throw new UtilsException(e.getMessage(),e);
  240.             }
  241.         }
  242.     }
  243.     public String listKeysCache(String separator) throws UtilsException{
  244.         if(this.cache!=null){
  245.             try{
  246.                 return this.cache.printKeys(separator);
  247.             }catch(Exception e){
  248.                 throw new UtilsException(e.getMessage(),e);
  249.             }
  250.         }else{
  251.             throw new UtilsException("Cache disabled");
  252.         }
  253.     }
  254.     public String getObjectCache(String key) throws UtilsException{
  255.         if(this.cache!=null){
  256.             try{
  257.                 Object o = this.cache.get(key);
  258.                 if(o!=null){
  259.                     return o.toString();
  260.                 }else{
  261.                     return "Object with key ["+key+"] not exists";
  262.                 }
  263.             }catch(Exception e){
  264.                 throw new UtilsException(e.getMessage(),e);
  265.             }
  266.         }else{
  267.             throw new UtilsException("Cache disabled");
  268.         }
  269.     }
  270.     public String removeObjectCache(String key) throws UtilsException{
  271.         if(this.cache!=null){
  272.             try{
  273.                 Object o = this.cache.get(key);
  274.                 if(o!=null){
  275.                     this.cache.remove(key);
  276.                     return "Object with key ["+key+"] deleted";
  277.                 }else{
  278.                     return "Object with key ["+key+"] not exists";
  279.                 }
  280.             }catch(Exception e){
  281.                 throw new UtilsException(e.getMessage(),e);
  282.             }
  283.         }else{
  284.             throw new UtilsException("Cache disabled");
  285.         }
  286.     }
  287.     
  288.     
  289.     
  290.     
  291.     
  292.     /* --------------- CacheWrapper --------------------*/
  293.     
  294.     public abstract Object getDriver(Object param) throws UtilsException;
  295.     public abstract boolean isCachableException(Throwable e);
  296.     
  297.     // Serve per poter sapere quale sia la chiave ed usarla nei metodi soprastanti
  298.     public String getKeyCache(String keyCacheParam,String methodName){
  299.         return this.buildKeyCache(keyCacheParam, methodName); 
  300.     }
  301.     
  302.     private String buildKeyCache(String keyCacheParam,String methodName){
  303.         if(keyCacheParam!=null && !"".equals(keyCacheParam))
  304.             return methodName + "." + keyCacheParam;
  305.         else
  306.             return methodName;
  307.     }
  308.     
  309.     public void duplicateObjectCache(String oldKeyCacheParam,String oldMethodName, 
  310.             String newKeyCacheParam,String newMethodName,
  311.             boolean debug,boolean throwExceptionIfNotExists) throws UtilsException{
  312.         
  313.         if(this.cache==null){
  314.             throw new UtilsException("Cache disabled");
  315.         }
  316.         
  317.         //synchronized(this.cache){
  318.         SemaphoreLock lock = this.lockCache.acquireThrowRuntime("duplicateObjectCache");
  319.         try {
  320.             
  321. //          if(debug){
  322. //              this.log.debug("@"+keyCache+"@ Cache info: "+this.cache.toString());
  323. //              this.log.debug("@"+keyCache+"@ Keys: \n\t"+this.cache.printKeys("\n\t"));
  324. //          }
  325.             
  326.             String oldKey = this.buildKeyCache(oldKeyCacheParam, oldMethodName);
  327.             org.openspcoop2.utils.cache.CacheResponse response = 
  328.                     (org.openspcoop2.utils.cache.CacheResponse) this.cache.get(oldKey);
  329.             if(response != null){
  330.                 String newKey = this.buildKeyCache(newKeyCacheParam, newMethodName);
  331.                 this.cache.remove(newKey);
  332.                 this.cache.put(newKey,response);
  333.                 this.log.debug("@"+newKey+"@ Entry add");
  334.             }
  335.             else{
  336.                 if(debug){
  337.                     this.log.debug("@"+oldKey+"@ Entry not exists");
  338.                 }
  339.                 if(throwExceptionIfNotExists){
  340.                     throw new UtilsException("Entry with key ["+oldKey+"] not exists");
  341.                 }
  342.             }
  343.         }finally {
  344.             this.lockCache.release(lock, "duplicateObjectCache");
  345.         }
  346.         
  347.     }
  348.     
  349.     public Object getObjectCache(Object driverParam,boolean debug,String keyCacheParam,String methodName,Object... arguments) throws Throwable{
  350.         return _getObjectCache(driverParam,debug,keyCacheParam,methodName,null,arguments);
  351.     }
  352.     public Object getObjectCache(Object driverParam,boolean debug,String keyCacheParam,String methodName,Class<?> [] cArguments, Object... arguments) throws Throwable{
  353.         return _getObjectCache(driverParam,debug,keyCacheParam,methodName,cArguments,arguments);
  354.     }
  355.     public Object _getObjectCache(Object driverParam,boolean debug,String keyCacheParam,String methodName,Class<?> [] cArguments, Object... arguments) throws Throwable{
  356.                 
  357.         
  358.         Throwable cachableException = null;
  359.         Throwable notCachableException = null;
  360.         Object obj = null;
  361.         boolean throwException = false;
  362.         
  363.         if(methodName == null)
  364.             throw new UtilsException("MethodName undefined");
  365.         
  366.         String keyCache = null;
  367.         
  368.         if(this.cache==null){
  369.             if(debug){
  370.                 this.log.debug("@method:"+methodName+"@ (Cache Disabled) search object with driver...");
  371.             }
  372.             try{
  373.                 obj = getObject(driverParam, debug, methodName, cArguments, arguments);
  374.             }catch(Throwable e){
  375.                 if(this.isCachableException(e)){
  376.                     cachableException = e;
  377.                 }
  378.                 else{
  379.                     notCachableException = e;
  380.                 }
  381.             }
  382.         }
  383.         else{
  384.         
  385.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  386. //          if(keyCacheParam == null)
  387. //              throw new UtilsException("["+methodName+"]: KeyCache undefined");   
  388.             keyCache = this.buildKeyCache(keyCacheParam, methodName);
  389.             
  390. //          if(debug){
  391. //              this.log.debug("@"+keyCache+"@ Cache info: "+this.cache.toString());
  392. //              this.log.debug("@"+keyCache+"@ Keys: \n\t"+this.cache.printKeys("\n\t"));
  393. //          }
  394.     
  395.             // se e' attiva una cache provo ad utilizzarla
  396.             org.openspcoop2.utils.cache.CacheResponse response = 
  397.                 (org.openspcoop2.utils.cache.CacheResponse) this.cache.get(keyCache);
  398.             if(response != null){
  399.                 if(response.getObject()!=null){
  400.                     if(debug){
  401.                         this.log.debug("@"+keyCache+"@ Object (type:"+response.getObject().getClass().getName()+") (method:"+methodName+") found in cache.");
  402.                     }
  403.                     return response.getObject();
  404.                 }
  405.                 else if(response.isObjectNull()){
  406.                     if(debug){
  407.                         this.log.debug("@"+keyCache+"@ Response null (method:"+methodName+") found in cache.");
  408.                     }
  409.                     return null;
  410.                 }
  411.                 else if(response.getException()!=null){
  412.                     this.log.debug("@"+keyCache+"@ Exception (type:"+response.getException().getClass().getName()+") (method:"+methodName+") found in cache.");
  413.                     throwException = true;
  414.                     throw (Throwable) response.getException();
  415.                 }else{
  416.                     this.log.error("@"+keyCache+"@ Found entry in cache with key ["+keyCache+"] (method:"+methodName+") without object and exception???");
  417.                 }
  418.             }
  419.             
  420.             //synchronized(this.cache){
  421.             SemaphoreLock lock = this.lockCache.acquire("getObjectCache");
  422.             try {
  423.                 
  424.                 try{
  425.                                         
  426. //                  if(debug){
  427. //                      this.log.debug("@"+keyCache+"@ Cache info: "+this.cache.toString());
  428. //                      this.log.debug("@"+keyCache+"@ Keys: \n\t"+this.cache.printKeys("\n\t"));
  429. //                  }
  430.         
  431.                     // se e' attiva una cache provo ad utilizzarla
  432.                     response = 
  433.                         (org.openspcoop2.utils.cache.CacheResponse) this.cache.get(keyCache);
  434.                     if(response != null){
  435.                         if(response.getObject()!=null){
  436.                             if(debug){
  437.                                 this.log.debug("@"+keyCache+"@ Object (type:"+response.getObject().getClass().getName()+") (method:"+methodName+") found in cache.");
  438.                             }
  439.                             return response.getObject();
  440.                         }
  441.                         else if(response.isObjectNull()){
  442.                             if(debug){
  443.                                 this.log.debug("@"+keyCache+"@ Response null (method:"+methodName+") found in cache.");
  444.                             }
  445.                             return null;
  446.                         }
  447.                         else if(response.getException()!=null){
  448.                             this.log.debug("@"+keyCache+"@ Exception (type:"+response.getException().getClass().getName()+") (method:"+methodName+") found in cache.");
  449.                             throwException = true;
  450.                             throw (Throwable) response.getException();
  451.                         }else{
  452.                             this.log.error("@"+keyCache+"@ Found entry in cache with key ["+keyCache+"] (method:"+methodName+") without object and exception???");
  453.                         }
  454.                     }
  455.         
  456.                     // Effettuo le query
  457.                     if(debug){
  458.                         this.log.debug("@"+keyCache+"@ search object (method:"+methodName+") with driver...");
  459.                     }
  460.                     boolean nullObject = false;
  461.                     boolean cacheble = false;
  462.                     try{
  463.                         obj = getObject(driverParam, debug, methodName, cArguments, arguments);
  464.                         nullObject = true;
  465.                         cacheble = true;
  466.                     }catch(Throwable e){
  467.                         if(this.isCachableException(e)){
  468.                             cachableException = e;
  469.                             cacheble = true;
  470.                         }
  471.                         else{
  472.                             notCachableException = e;
  473.                         }
  474.                     }
  475.                     
  476.                             
  477.                     // Aggiungo la risposta in cache (se esiste una cache)  
  478.                     // Se ho una eccezione aggiungo in cache solo una not found
  479.                     if( cacheble ){     
  480.                         try{    
  481.                             org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  482.                             if(cachableException!=null){
  483.                                 if(debug){
  484.                                     this.log.debug("@"+keyCache+"@ Add Exception in cache");
  485.                                 }
  486.                                 responseCache.setException(cachableException);
  487.                             }else if(obj!=null){
  488.                                 if(debug){
  489.                                     this.log.debug("@"+keyCache+"@ Add Object in cache");
  490.                                 }
  491.                                 responseCache.setObject((java.io.Serializable)obj);
  492.                             }else if(nullObject){
  493.                                 if(debug){
  494.                                     this.log.debug("@"+keyCache+"@ Add Null Response in cache");
  495.                                 }
  496.                                 responseCache.setObjectNull(true);
  497.                             }
  498.                             this.cache.put(keyCache,responseCache);
  499.                         }catch(UtilsException e){
  500.                             this.log.error("@"+keyCache+"@ error occurs during insert in cache: "+e.getMessage(),e);
  501.                         }
  502.                     }
  503.         
  504.                 }catch(Throwable e){
  505.                     if(throwException == false){
  506.                         this.log.error("@"+keyCache+"@ Error occurs: "+e.getMessage(),e);
  507.                         throw new UtilsException(e.getMessage(),e);
  508.                     }
  509.                     else{
  510.                         cachableException = e;
  511.                     }
  512.                 }
  513.                 
  514.             }finally {
  515.                 this.lockCache.release(lock, "getObjectCache");
  516.             }
  517.         }
  518.         
  519.         String cacheMsg = "";
  520.         if(this.cache!=null && keyCache!=null){
  521.             cacheMsg = "@key:"+keyCache+"@";
  522.         }
  523.         else{
  524.             cacheMsg = "@method:"+methodName+"@";
  525.         }
  526.         if(cachableException!=null){
  527.             if(debug){
  528.                 this.log.debug(cacheMsg+" throw CachableException: "+cachableException.getClass().getName());
  529.             }
  530.             throw cachableException;
  531.         }
  532.         else if(notCachableException!=null){
  533.             if(debug){
  534.                 this.log.debug(cacheMsg+" throw NotCachableException: "+notCachableException.getClass().getName());
  535.             }
  536.             throw notCachableException;
  537.         }
  538.         else if(obj!=null){
  539.             if(debug){
  540.                 this.log.debug(cacheMsg+" return Object: "+obj.getClass().getName());
  541.             }
  542.             return obj;
  543.         }else{
  544.             if(debug){
  545.                 this.log.debug(cacheMsg+" return null response");
  546.             }
  547.             return null;
  548.         }
  549.     }
  550.     
  551.     private Object getObject(Object driverParam,boolean debug,String methodName,Class<?> [] cArguments, Object... arguments) throws Throwable{

  553.         
  554.         // Effettuo le query nella mia gerarchia di registri.
  555.         Object obj = null;
  556.         try{
  557.             Object driver = this.getDriver(driverParam);
  558.             if(driver==null){
  559.                 throw new UtilsException("Driver undefined");
  560.             }
  561.             if(arguments.length==0){
  562.                 Method method =  driver.getClass().getMethod(methodName);
  563.                 obj = method.invoke(driver);
  564.             }else if(arguments.length==1){
  565.                 Method method =  driver.getClass().getMethod(methodName,
  566.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()));
  567.                 obj = method.invoke(driver,
  568.                         arguments[0]);
  569.             }else if(arguments.length==2){
  570.                 Method method =  driver.getClass().getMethod(methodName,
  571.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  572.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()));
  573.                 obj = method.invoke(driver,
  574.                         arguments[0],
  575.                         arguments[1]);
  576.             }else if(arguments.length==3){
  577.                 Method method =  driver.getClass().getMethod(methodName,
  578.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  579.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  580.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()));
  581.                 obj = method.invoke(driver,
  582.                         arguments[0],
  583.                         arguments[1],
  584.                         arguments[2]);
  585.             }else if(arguments.length==4){
  586.                 Method method =  driver.getClass().getMethod(methodName,
  587.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  588.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  589.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  590.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()));
  591.                 obj = method.invoke(driver,
  592.                         arguments[0],
  593.                         arguments[1],
  594.                         arguments[2],
  595.                         arguments[3]);
  596.             }else if(arguments.length==5){
  597.                 Method method =  driver.getClass().getMethod(methodName,
  598.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  599.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  600.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  601.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  602.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()));
  603.                 obj = method.invoke(driver,
  604.                         arguments[0],
  605.                         arguments[1],
  606.                         arguments[2],
  607.                         arguments[3],
  608.                         arguments[4]);
  609.             }else if(arguments.length==6){
  610.                 Method method =  driver.getClass().getMethod(methodName,
  611.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  612.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  613.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  614.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  615.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  616.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()));
  617.                 obj = method.invoke(driver,
  618.                         arguments[0],
  619.                         arguments[1],
  620.                         arguments[2],
  621.                         arguments[3],
  622.                         arguments[4],
  623.                         arguments[5]);
  624.             }else if(arguments.length==7){
  625.                 Method method =  driver.getClass().getMethod(methodName,
  626.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  627.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  628.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  629.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  630.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  631.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  632.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()));
  633.                 obj = method.invoke(driver,
  634.                         arguments[0],
  635.                         arguments[1],
  636.                         arguments[2],
  637.                         arguments[3],
  638.                         arguments[4],
  639.                         arguments[5],
  640.                         arguments[6]);
  641.             }else if(arguments.length==8){
  642.                 Method method =  driver.getClass().getMethod(methodName,
  643.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  644.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  645.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  646.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  647.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  648.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  649.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  650.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()));
  651.                 obj = method.invoke(driver,
  652.                         arguments[0],
  653.                         arguments[1],
  654.                         arguments[2],
  655.                         arguments[3],
  656.                         arguments[4],
  657.                         arguments[5],
  658.                         arguments[6],
  659.                         arguments[7]);
  660.             }else if(arguments.length==9){
  661.                 Method method =  driver.getClass().getMethod(methodName,
  662.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  663.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  664.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  665.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  666.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  667.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  668.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  669.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  670.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()));
  671.                 obj = method.invoke(driver,
  672.                         arguments[0],
  673.                         arguments[1],
  674.                         arguments[2],
  675.                         arguments[3],
  676.                         arguments[4],
  677.                         arguments[5],
  678.                         arguments[6],
  679.                         arguments[7],
  680.                         arguments[8]);
  681.             }else if(arguments.length==10){
  682.                 Method method =  driver.getClass().getMethod(methodName,
  683.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  684.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  685.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  686.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  687.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  688.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  689.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  690.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  691.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()),
  692.                         (cArguments!=null ? cArguments[9] :arguments[9].getClass()));
  693.                 obj = method.invoke(driver,
  694.                         arguments[0],
  695.                         arguments[1],
  696.                         arguments[2],
  697.                         arguments[3],
  698.                         arguments[4],
  699.                         arguments[5],
  700.                         arguments[6],
  701.                         arguments[7],
  702.                         arguments[8],
  703.                         arguments[9]);
  704.             }else if(arguments.length==11){
  705.                 Method method =  driver.getClass().getMethod(methodName,
  706.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  707.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  708.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  709.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  710.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  711.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  712.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  713.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  714.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()),
  715.                         (cArguments!=null ? cArguments[9] :arguments[9].getClass()),
  716.                         (cArguments!=null ? cArguments[10] :arguments[10].getClass()));
  717.                 obj = method.invoke(driver,
  718.                         arguments[0],
  719.                         arguments[1],
  720.                         arguments[2],
  721.                         arguments[3],
  722.                         arguments[4],
  723.                         arguments[5],
  724.                         arguments[6],
  725.                         arguments[7],
  726.                         arguments[8],
  727.                         arguments[9],
  728.                         arguments[10]);
  729.             }else if(arguments.length==12){
  730.                 Method method =  driver.getClass().getMethod(methodName,
  731.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  732.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  733.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  734.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  735.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  736.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  737.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  738.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  739.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()),
  740.                         (cArguments!=null ? cArguments[9] :arguments[9].getClass()),
  741.                         (cArguments!=null ? cArguments[10] :arguments[10].getClass()),
  742.                         (cArguments!=null ? cArguments[11] :arguments[11].getClass()));
  743.                 obj = method.invoke(driver,
  744.                         arguments[0],
  745.                         arguments[1],
  746.                         arguments[2],
  747.                         arguments[3],
  748.                         arguments[4],
  749.                         arguments[5],
  750.                         arguments[6],
  751.                         arguments[7],
  752.                         arguments[8],
  753.                         arguments[9],
  754.                         arguments[10],
  755.                         arguments[11]); 
  756.             }else if(arguments.length==13){
  757.                 Method method =  driver.getClass().getMethod(methodName,
  758.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  759.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  760.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  761.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  762.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  763.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  764.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  765.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  766.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()),
  767.                         (cArguments!=null ? cArguments[9] :arguments[9].getClass()),
  768.                         (cArguments!=null ? cArguments[10] :arguments[10].getClass()),
  769.                         (cArguments!=null ? cArguments[11] :arguments[11].getClass()),
  770.                         (cArguments!=null ? cArguments[12] :arguments[12].getClass()));
  771.                 obj = method.invoke(driver,
  772.                         arguments[0],
  773.                         arguments[1],
  774.                         arguments[2],
  775.                         arguments[3],
  776.                         arguments[4],
  777.                         arguments[5],
  778.                         arguments[6],
  779.                         arguments[7],
  780.                         arguments[8],
  781.                         arguments[9],
  782.                         arguments[10],
  783.                         arguments[11],
  784.                         arguments[12]); 
  785.             }else if(arguments.length==14){
  786.                 Method method =  driver.getClass().getMethod(methodName,
  787.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  788.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  789.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  790.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  791.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  792.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  793.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  794.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  795.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()),
  796.                         (cArguments!=null ? cArguments[9] :arguments[9].getClass()),
  797.                         (cArguments!=null ? cArguments[10] :arguments[10].getClass()),
  798.                         (cArguments!=null ? cArguments[11] :arguments[11].getClass()),
  799.                         (cArguments!=null ? cArguments[12] :arguments[12].getClass()),
  800.                         (cArguments!=null ? cArguments[13] :arguments[13].getClass()));
  801.                 obj = method.invoke(driver,
  802.                         arguments[0],
  803.                         arguments[1],
  804.                         arguments[2],
  805.                         arguments[3],
  806.                         arguments[4],
  807.                         arguments[5],
  808.                         arguments[6],
  809.                         arguments[7],
  810.                         arguments[8],
  811.                         arguments[9],
  812.                         arguments[10],
  813.                         arguments[11],
  814.                         arguments[12],
  815.                         arguments[13]); 
  816.             }else if(arguments.length==15){
  817.                 Method method =  driver.getClass().getMethod(methodName,
  818.                         (cArguments!=null ? cArguments[0] :arguments[0].getClass()),
  819.                         (cArguments!=null ? cArguments[1] :arguments[1].getClass()),
  820.                         (cArguments!=null ? cArguments[2] :arguments[2].getClass()),
  821.                         (cArguments!=null ? cArguments[3] :arguments[3].getClass()),
  822.                         (cArguments!=null ? cArguments[4] :arguments[4].getClass()),
  823.                         (cArguments!=null ? cArguments[5] :arguments[5].getClass()),
  824.                         (cArguments!=null ? cArguments[6] :arguments[6].getClass()),
  825.                         (cArguments!=null ? cArguments[7] :arguments[7].getClass()),
  826.                         (cArguments!=null ? cArguments[8] :arguments[8].getClass()),
  827.                         (cArguments!=null ? cArguments[9] :arguments[9].getClass()),
  828.                         (cArguments!=null ? cArguments[10] :arguments[10].getClass()),
  829.                         (cArguments!=null ? cArguments[11] :arguments[11].getClass()),
  830.                         (cArguments!=null ? cArguments[12] :arguments[12].getClass()),
  831.                         (cArguments!=null ? cArguments[13] :arguments[13].getClass()),
  832.                         (cArguments!=null ? cArguments[14] :arguments[14].getClass()));
  833.                 obj = method.invoke(driver,
  834.                         arguments[0],
  835.                         arguments[1],
  836.                         arguments[2],
  837.                         arguments[3],
  838.                         arguments[4],
  839.                         arguments[5],
  840.                         arguments[6],
  841.                         arguments[7],
  842.                         arguments[8],
  843.                         arguments[9],
  844.                         arguments[10],
  845.                         arguments[11],
  846.                         arguments[12],
  847.                         arguments[13],
  848.                         arguments[14]);
  849.             }else
  850.                 throw new Exception("More than 15 arguments unsupported");
  851.         }catch(java.lang.reflect.InvocationTargetException e){
  852.             if(e.getTargetException()!=null){
  853.                 throw e.getTargetException();
  854.             }else{
  855.                 throw e;
  856.             }
  857.         }
  858.         catch(Exception e){
  859.             throw e;
  860.         }
  861.         
  862.         return obj;
  863.         
  864.     }
  865. }
Created with JaCoCo 0.8.8.202204050719