WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/util/Util.java


package org.tela_botanica.client.util;
 
import java.text.NumberFormat;
import java.text.ParsePosition;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Vector;
 
import org.tela_botanica.client.i18n.Msg;
import org.tela_botanica.client.modeles.objets.ChampEtendu;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.Observation;
import org.tela_botanica.client.modeles.objets.ReferentielLocalite;
import org.tela_botanica.client.modeles.objets.ReferentielNom;
 
import com.google.gwt.core.client.Callback;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestCallback;
import com.google.gwt.http.client.RequestException;
import com.google.gwt.http.client.Response;
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.json.client.JSONParser;
import com.google.gwt.json.client.JSONString;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.ui.RootPanel;
 
public class Util {
 
	public Util() {
	}
	
	public static String getValeurJsonOuVide(JSONObject jo, String index) {
		return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : "";
	}
	
	public static Map<String, ChampEtendu> getMapValeursOuVide(JSONObject jo, String index) {
		Map<String, ChampEtendu> mapValeurs = new HashMap<String, ChampEtendu>();
		if(jo.get(index) != null && jo.get(index).isArray() != null) {	
			JSONArray tabJo = jo.get(index).isArray();
			for (int i = 0; i < tabJo.size(); i++) {
				JSONObject champJson = tabJo.get(i).isObject();
				String cle = champJson.get("cle").isString().stringValue();
				String label = cle;
				String valeur = champJson.get("valeur").isString().stringValue();
				ChampEtendu champ = new ChampEtendu(cle, label, valeur);
				mapValeurs.put(cle, champ);
			}
 
		}
		return mapValeurs;
	}
	
	public static String convertirChampsEtendusEnChaineRequete(Map<String, ChampEtendu> map) {
		String json = "";
	    if (map != null && !map.isEmpty()) {
	    	JSONArray jsonArr = new JSONArray();
	    	int i = 0;
	        for (Map.Entry<String, ChampEtendu> entry: map.entrySet()) {
	        	jsonArr.set(i, convertirChampEtenduEnJson(entry.getValue()));
	        	i++;
	        }
	        json = jsonArr.toString();
	    }
	    return json;
	}
	
	public static JSONObject convertirChampEtenduEnJson(ChampEtendu champEtendu) {
		JSONObject jsonObj = new JSONObject();
		jsonObj.put("cle", new JSONString(champEtendu.getCle()));
		jsonObj.put("label", new JSONString(champEtendu.getLabel()));
		jsonObj.put("valeur", new JSONString(champEtendu.getValeur()));
        return jsonObj;
	}
	
	public static boolean jsonNonNull(JSONObject jo, String index) {
		return (jo != null && 
				jo.get(index) != null && 
				jo.get(index).isNull() == null
			   );			
	}
	
	public static String formaterLieu(Observation obs, String modeleLieu) {
		
		String lieuModele = modeleLieu;
		
		String localite = obs.getLocalite(); 
		String lieuDit = obs.getLieudit();
		String station = obs.getStation();
		
		String lieulocaliteFormate = "";
		String lieuDitFormate = "";
		String stationFormatee = "";
		
		if(localite != null && !localite.contains("000null") && !localite.trim().equals("")) {
			String	idLoc =obs.getIdentifiantLocalite().replaceAll(" ","/");
			if(idLoc != null && !idLoc.contains("000null") && !idLoc.trim().equals("")) {
 
				idLoc = idLoc.replaceAll("%","");
				idLoc = idLoc.replaceAll("\"","");
				idLoc = idLoc.replace('\\',' ');
				idLoc = idLoc.trim();
				if(idLoc.length() > 2) {
					idLoc = idLoc.substring(0,2);
				}
				lieulocaliteFormate += idLoc+" - ";
			}
			lieulocaliteFormate += localite;
			lieuModele = lieuModele.replaceAll("IDLOCLOCALITE", lieulocaliteFormate);
		} else {
			
			lieuModele = lieuModele.replaceAll("IDLOCLOCALITE,", lieulocaliteFormate);
		}
		
		if(lieuDit != null && !lieuDit.contains("000null") && !lieuDit.trim().equals("")) {
			lieuDitFormate += lieuDit;
			lieuModele = lieuModele.replaceAll("LIEUDIT", lieuDitFormate);
		} else {
			lieuModele = lieuModele.replaceAll("LIEUDIT,", lieuDitFormate);
		}
		
		if(station != null && !station.contains("000null") && !station.trim().equals("")) {
			stationFormatee += station;
			lieuModele = lieuModele.replaceAll("STATION", stationFormatee);
		} else {
			lieuModele = lieuModele.replaceAll("STATION", stationFormatee);
		}
		
		lieuModele = lieuModele.trim();
		lieuModele = lieuModele.replaceAll(",$","");
		lieuModele = lieuModele.replaceAll(",^$",", ");
		
		return lieuModele;
	}
	
	public static String obtenirIdLocAPartirChaineLocalite(String localite) {
		
		String idLoc = "";	
		String[] depCom = localite.split(" ");
		if(depCom.length > 1) {
			idLoc = depCom[1].replace('(', ' ');
		} else {
			idLoc = "";
		}
		
		idLoc = idLoc.replace(')', ' ');
		idLoc = idLoc.trim();
		idLoc = idLoc.replace('\\',' ');
		idLoc = idLoc.trim();
		
		return idLoc;
	}
	
	public static String formaterDepartement(String depAFormater) {	
		String dep = "";
		try
		{
			int nDep = Integer.parseInt(depAFormater);
			if(nDep > 0 && nDep < 110) {
				dep = depAFormater ;
			}
			
			if(depAFormater.length() == 4) {
				dep = "0"+depAFormater;
			}
			
			dep = depAFormater.substring(0,2);
		}
		catch(NumberFormatException e)
		{
			// rien à faire
		}
		
		return dep;
	}
	
	public static String supprimerChaineIdLocalite(String chaineLocaliteComplete) {
		return chaineLocaliteComplete.replaceAll(" \\([a-zA-Z0-9]*\\)", "").trim();
	}
	
	public static String convertirChaineZoneGeoVersDepartement(String chaineZoneGeo) {
		return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("") && chaineZoneGeo.replaceAll("INSEE-C:", "").length() >= 2) ? 
						chaineZoneGeo.replaceAll("INSEE-C:", "").substring(0, 2) : 
						chaineZoneGeo;
	}
	
	public static String convertirChaineZoneGeoVersCodeInsee(String chaineZoneGeo) {
		return (!chaineZoneGeo.equals("000null") && !chaineZoneGeo.equals("")) ? chaineZoneGeo.replaceAll("INSEE-C:", ""): chaineZoneGeo;
	}
	
	/***
	 * Fusionne les éléments d'un tableau en une chaîne
	 * @param delim : la chaîne de séparation
	 * @param args : la tableau
	 * @return la chaîne fusionnée
	 */
	public static String implode(String delim, String[] args){
		StringBuffer sb = new StringBuffer();
		
		int lgArgs = args.length;
		
		for(int i = 0; i < lgArgs; i++){
			if (i > 0) {
				sb.append(delim);
			}
			
			sb.append(args[i]);
		}
		
		return sb.toString();
	}
	
	public static boolean filtreValide(String[] filtre) {
		
		return (filtre.length == 2 && 
		filtre[0] != null &&
		!filtre[0].equals("") &&
		filtre[1] != null &&
		!filtre[1].equals(""));
	}
	
	public static String renvoyerMois(int numMois) {
			
		if(numMois >= 1 && numMois <= 12) {
			return Msg.get("mois-"+numMois);
		} else {
			return Msg.get("mois-inconnu") ;
		}
	}
	
	public static String remplacerSautsDeligneMalEncodes(String chaineAvecSautsDeLignesMalEncodes) {
		
		String chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesMalEncodes.replace('\\','%');
		chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replaceAll("%n","%");
		chaineAvecSautsDeLignesBienEncodes = chaineAvecSautsDeLignesBienEncodes.replace('%','\n');
		
		return chaineAvecSautsDeLignesBienEncodes;
	}
	
	public static boolean verifierDateFormatCel(String dateAVerifier) {
		
		String dateRemplacee = remplacerSeparateursDateFormatCel(dateAVerifier);	
		String[] tabDate = dateRemplacee.split("/");
		
		boolean retour = false;
		
		if(tabDate.length == 3) {
			//TODO: faire un parsing de date qui fonctionne mieux car 
			// on peut saisir un 31 novembre par exemple
			// mais l'api date de java est mal gérée par gwt
			try {
				int jour = Integer.parseInt(tabDate[0]);
				int mois = Integer.parseInt(tabDate[1]);
				int annee = Integer.parseInt(tabDate[2]);
				
				if(jour <= 31 && mois <= 12 && tabDate[2].length() == 4) {
					retour = true;
				}
			} catch (Exception e) {
 
			}
		}
		    
		return retour;
	}
	
	public static String remplacerSeparateursDateFormatCel(String date) {
		
		String dateRemplacee = date.replaceAll("-", "/");
	    
	    return dateRemplacee;
	}
	
	public static boolean estZero(String s) {
		boolean estZero = false;
	    try { 
	    	Double dou = Double.parseDouble(s); 
	    	estZero = (dou == 0);
	    } catch(NumberFormatException e) { 
 
	    }
	    return estZero;
	}
	
	public static boolean estUnNombre(String s) {
		//http://stackoverflow.com/questions/1102891/how-to-check-if-a-string-is-a-numeric-type-in-java
		try {  
			double d = Double.parseDouble(s);  
		} catch(NumberFormatException nfe) {  
			return false;  
		}  
		return true;  
	}
	
	public static boolean estLaCorse(String s) {
		// Les générations futures d'informaticiens me jugeront
		// (et éventuellement géreront mieux le cas de la Corse que je ne l'ai fait)
		return s.toUpperCase().equals("2A") || s.toUpperCase().equals("2B");
	}
	
	public static boolean estUnDepartement(String s) {
		return estUnNombre(s) || estLaCorse(s);
	}
	
	public static String formaterNombre(String s) {
		s = s.indexOf(".") < 0 ? s : s.replaceAll("0*$", "").replaceAll("\\.$", "");
		return s;
	}
 
	// Prend un nombre décimal avec le spéparateur spécifié et le tronque à n décimales
	public static String tronquerNombrePourAffichage(String nombre, int decimales, char separateur) {
		String retour = nombre;
		int posSep = nombre.indexOf(separateur);
		if (posSep >= 0) {
			int taille = posSep + decimales + 1;
			if (nombre.length() < taille) {
				taille = nombre.length();
			}
			retour = nombre.substring(0, taille);
		}
		return retour;
	}
 
	public static String tronquerNombrePourAffichage(String nombre, int decimales) {
		return tronquerNombrePourAffichage(nombre, decimales, '.');
	}
	
	// Adapté de http://www.programcreek.com/2011/03/java-method-for-spliting-a-camelcase-string/
	public static String formaterCleChampsEtenduPourAffichage(String s) {
		char[] cArray = s.toCharArray();
		 
		Vector<Integer> al = new Vector<Integer>();
		al.add(0);
	 
		// get all upper case letter index positions
		for (int i = 1; i < cArray.length; i++) {
			char c = cArray[i];
			//add more interested index beyond upper case letter
			if (c >= 65 && c <= 90) {
				al.add(i);
			}
		}
	 
		Vector<String> strl = new Vector<String>();
	 
		// this handles the all lower letter case
		if (al.size() == 1) {
			strl.add(s);
			return depilerChaineListee(strl, " ");
		}
	 
	 
		int prev = 0;
		int curr = 0;
		int begin = 0;
		for (int k = 1; k < al.size(); k++) {
	 
			curr = al.get(k);
	 
			if(curr == s.length() - 1){
	 
			}
	 
			if (curr == prev + 1 && curr != s.length() - 1) {
				prev = curr;
			} else if(curr == prev + 1 &&  curr == s.length() - 1){
				strl.add(s.substring(begin, curr+1));
			}else {
	 
				strl.add(s.substring(prev, curr));
				prev = curr;
				begin = curr;
				if (k == al.size() - 1) {
					strl.add(s.substring(curr, s.length()));
				}
			}
		}
	 
		return depilerChaineListee(strl, " ");
	}
	
	private static String depilerChaineListee(Vector<String> strl, String separateur) {
		String s = "";
		for(int i = 0; i < strl.size(); i++) {
			s += strl.get(i);
			if(i != strl.size() - 1) {
				s += separateur;
			}
		}
		return s;
	}
	
	public static Map<String, ChampEtendu> trierListeChampsEtendus(Map<String, ChampEtendu> listeChampsEtendus) {
		List<String> tmp = new ArrayList<String>(listeChampsEtendus.keySet());
		Collections.sort(tmp, new Comparator<String>() {
			 
		    @Override
		    public int compare(String arg0, String arg1) {
		        return arg0.compareTo(arg1);
		    }
		 
		});
		return listeChampsEtendus;
	}
	
	/**
	 * Solution issue de stackoverflow : 
	 * http://stackoverflow.com/questions/1143951/what-is-the-simplest-way-to-convert-a-java-string-from-all-caps-words-separated
	 */
	public static String convertirEnChaMot(String s) {	
		s = s.replaceAll("_", " ");
		s = s.replaceAll("-", " ");
		String[] parties = s.split(" ");
		String chaineChaMot = "";
		for (String partie : parties){
			chaineChaMot = chaineChaMot + convertirMotEnChaMot(partie);
		}
		return chaineChaMot;
	}
 
	protected static String convertirMotEnChaMot(String s) {
		// MiaOu
		return s.substring(0, 1).toUpperCase() +
	               s.substring(1).toLowerCase();
	}
 
	public static void curseurAttente() {
	    RootPanel.getBodyElement().getStyle().setProperty("cursor", "wait");
	}
 
	public static void curseurParDefaut() {
		RootPanel.getBodyElement().getStyle().setProperty("cursor", "default");
	}
	
	public static Map<String, String> parserRetourReferentielPerso(Response response) {
		final Map<String, String> referentielData = new HashMap<String, String>();
		final JSONValue responseValue = JSONParser.parse(response.getText());
		
		JSONArray reponse = null;
 
		// si c'est un tableau
		if ((reponse = responseValue.isArray()) != null) {
			
			JSONString elementsRef;
			final int taillemax = reponse.size();
			
			for (int i = 0; i < taillemax; i++) {
				if ((elementsRef = reponse.get(i).isString()) != null) {
					
					String valeur = elementsRef.stringValue();
					referentielData.put(i+"", valeur);
							
				}	
			}
		}
		return referentielData;
	}
	
	public static Map<String, ReferentielNom> parserRetourReferentielNomIndexeParNom(Response response) {
		
		final Map<String, ReferentielNom> referentielNomData ;
		final JSONValue responseValue = JSONParser.parse(response.getText());
		JSONArray reponse=null;
 
		// si c'est un tableau
		if ((reponse=responseValue.isArray()) != null) {
			
			JSONArray noms;
			final int taillemax = reponse.size();
			
			referentielNomData = new HashMap<String, ReferentielNom>(taillemax);
			for (int i = 0; i < taillemax; i++) {
				if ((noms=reponse.get(i).isArray()) != null) {
					String nom = ((JSONString) noms.get(0)).stringValue();
					String numeroNom = ((JSONString) noms.get(1)).stringValue();
					String statut= ((JSONString) noms.get(2)).stringValue();
					ReferentielNom nomScientifique = new ReferentielNom(nom, numeroNom, statut);
					// clef améliorée : permet de désambiguiser les noms identiques
					// (ex: Scilla bifolia)
					referentielNomData.put(numeroNom + "|" + nom, nomScientifique);
				}
			}
		} else {	
			referentielNomData = new HashMap<String, ReferentielNom>(0);
		}
		return referentielNomData;
	}
 
	public static Map<String, String> convertirListeReferentielNomVersMap(Map<String, ReferentielNom> referentielNom) {
		Map<String, String> nomMap = new HashMap<String, String>();
		for (Iterator<String> it  = referentielNom.keySet().iterator(); it.hasNext();) {
			String cle = it.next();
			nomMap.put(cle, referentielNom.get(cle).getNom());
		}
		return nomMap;
	}
	
	public static Map<String, ReferentielLocalite> parserRetourReferentielLocaliteIndexeParNom(Response response) {
		
		final Map<String, ReferentielLocalite> referentielLocaliteData;					
		final JSONValue responseValue = JSONParser.parse(response.getText());					
		JSONArray reponse = null;
 
		// si c'est un tableau
		if ((reponse = responseValue.isArray()) != null) {
			
			JSONArray localites;
			final int taillemax = reponse.size();
			
			referentielLocaliteData = new HashMap<String, ReferentielLocalite>(taillemax);
			
			for (int i = 0; i < taillemax; i++) {
				if ((localites = reponse.get(i).isArray()) != null) {
					String localite = ((JSONString) localites.get(0)).stringValue();
					String codeLocalite  = ((JSONString) localites.get(1)).stringValue();
					ReferentielLocalite com = new ReferentielLocalite(localite, codeLocalite);
					referentielLocaliteData.put(com.getLocalite(), com);			
				}	
			}
		} else {					
			referentielLocaliteData = new HashMap<String, ReferentielLocalite>(0);
		}					
		return referentielLocaliteData;
	}
	
	public static Map<String, String> convertirListeReferentielLocaliteVersMap(Map<String, ReferentielLocalite> referentielLocalite) {
		Map<String, String> locMap = new HashMap<String, String>();
		for (Iterator<String> it  = referentielLocalite.keySet().iterator(); it.hasNext();) {
			String cle = it.next();
			locMap.put(cle, referentielLocalite.get(cle).getLocalite());
		}
		return locMap;
	}
	
	public static Map<String, String> parserRetourImportObs(String json) {
		final JSONValue responseValue = JSONParser.parse(json);
		JSONObject reponse = null;
		
		Map<String, String> retourImport = new HashMap<String,String>();
		// si c'est un objet
		if ((reponse = responseValue.isObject()) != null) {
			Iterator<String> it = reponse.keySet().iterator();
			
			while(it.hasNext()) {
				String cle = it.next();								
				String valeur = reponse.get(cle).isString().stringValue();
				retourImport.put(cle, valeur);
			}
		}
		
		return retourImport;
	}
	
	public static void envoyerRequeteStatsUpload(final Callback<String, String> cb) {			
		RequestBuilderWithCredentials rb = new RequestBuilderWithCredentials(RequestBuilderWithCredentials.GET,Configuration.getServiceBaseUrl()
				+"/ImportXLS") ;
		try {
			rb.sendRequest(null, new RequestCallback() {
 
				@Override
				public void onError(Request request, Throwable exception) {
					// TODO Auto-generated method stub	
				}
 
				@Override
				public void onResponseReceived(Request request,
						Response response) {
					cb.onSuccess(response.getText());	
				}
			}) ;
 
		} catch (RequestException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	public static native void  LogVersFirebug(Object o) /*-{
		if (!!($wnd.console && $wnd.console.log)) {
			console.log(o);
		}
	}-*/;
	
	public static String buildStackTrace(Throwable t, String log) {
	    if (t != null) {
		     log += t.getClass().toString();
		     log += t.getMessage();
		     //
		     StackTraceElement[] stackTrace = t.getStackTrace();
		     if (stackTrace != null) {
		    	 StringBuffer trace = new StringBuffer();
		    
			     for (int i = 0; i < stackTrace.length; i++) {
			    	 trace.append(stackTrace[i].getClassName() + "." + stackTrace[i].getMethodName() + "("
			    			 + stackTrace[i].getFileName() + ":" + stackTrace[i].getLineNumber());
			     }
		    
			     log += trace.toString();
		     }
		     //
		     Throwable cause = t.getCause();
		     if (cause != null && cause != t) {
		    	 log += buildStackTrace(cause, "CausedBy:\n");
		     }
	    }
	    return log;
	}
	
	public static String obtenirCodeLangueSysteme() {
		String langueSystemeBrute = obtenirLangueSysteme();
		// le navigateur peut éventuellement renvoyer une chaine de la forme
		// en-us ou fr-fr par exemple
		String[] lngTab = langueSystemeBrute.split("-");		
		return (lngTab.length > 0) ? lngTab[0] : null;
	}
	
	public static native String obtenirLangueSysteme()  /*-{
		lang = "";
		if (!!($wnd.navigator && $wnd.navigator.language)) {
			lang = window.navigator.language;
		}
		return lang;
	}-*/;
}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/util/Util.java – Rev 2693 → 2734

Rev 2693		Rev 2734
1	`package org.tela_botanica.client.util;`	1	`package org.tela_botanica.client.util;`
2		2
3	`import java.text.NumberFormat;`	3	`import java.text.NumberFormat;`
4	`import java.text.ParsePosition;`	4	`import java.text.ParsePosition;`
5	`import java.util.ArrayList;`	5	`import java.util.ArrayList;`
6	`import java.util.Collections;`	6	`import java.util.Collections;`
7	`import java.util.Comparator;`	7	`import java.util.Comparator;`
8	`import java.util.HashMap;`	8	`import java.util.HashMap;`
9	`import java.util.Iterator;`	9	`import java.util.Iterator;`
10	`import java.util.List;`	10	`import java.util.List;`
11	`import java.util.Map;`	11	`import java.util.Map;`
12	`import java.util.Vector;`	12	`import java.util.Vector;`
13		13
14	`import org.tela_botanica.client.i18n.Msg;`	14	`import org.tela_botanica.client.i18n.Msg;`
15	`import org.tela_botanica.client.modeles.objets.ChampEtendu;`	15	`import org.tela_botanica.client.modeles.objets.ChampEtendu;`
16	`import org.tela_botanica.client.modeles.objets.Configuration;`	16	`import org.tela_botanica.client.modeles.objets.Configuration;`
17	`import org.tela_botanica.client.modeles.objets.Observation;`	17	`import org.tela_botanica.client.modeles.objets.Observation;`
18	`import org.tela_botanica.client.modeles.objets.ReferentielLocalite;`	18	`import org.tela_botanica.client.modeles.objets.ReferentielLocalite;`
19	`import org.tela_botanica.client.modeles.objets.ReferentielNom;`	19	`import org.tela_botanica.client.modeles.objets.ReferentielNom;`
20		20
21	`import com.google.gwt.core.client.Callback;`	21	`import com.google.gwt.core.client.Callback;`
22	`import com.google.gwt.http.client.Request;`	22	`import com.google.gwt.http.client.Request;`
23	`import com.google.gwt.http.client.RequestCallback;`	23	`import com.google.gwt.http.client.RequestCallback;`
24	`import com.google.gwt.http.client.RequestException;`	24	`import com.google.gwt.http.client.RequestException;`
25	`import com.google.gwt.http.client.Response;`	25	`import com.google.gwt.http.client.Response;`
26	`import com.google.gwt.json.client.JSONArray;`	26	`import com.google.gwt.json.client.JSONArray;`
27	`import com.google.gwt.json.client.JSONObject;`	27	`import com.google.gwt.json.client.JSONObject;`
28	`import com.google.gwt.json.client.JSONParser;`	28	`import com.google.gwt.json.client.JSONParser;`
29	`import com.google.gwt.json.client.JSONString;`	29	`import com.google.gwt.json.client.JSONString;`
30	`import com.google.gwt.json.client.JSONValue;`	30	`import com.google.gwt.json.client.JSONValue;`
31	`import com.google.gwt.user.client.ui.RootPanel;`	31	`import com.google.gwt.user.client.ui.RootPanel;`
32		32
33	`public class Util {`	33	`public class Util {`
34		34
35	`public Util() {`	35	`public Util() {`
36	`}`	36	`}`
37		37
38	`public static String getValeurJsonOuVide(JSONObject jo, String index) {`	38	`public static String getValeurJsonOuVide(JSONObject jo, String index) {`
39	`return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : "";`	39	`return jsonNonNull(jo, index) ? ((JSONString)jo.get(index)).stringValue() : "";`
40	`}`	40	`}`