commit 721586e8453c2b28e570271f51395b1f85c61524 Author: Benediktwismans Date: Sun Feb 2 11:13:57 2025 +0100 first commit diff --git a/README.md b/README.md new file mode 100644 index 0000000..79285e0 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +Zugferd-Injektor als Web-Service, der ein PDF-Dokuemnt sowie ein JSON-Objekt entgegennimmt und ein Zugferd-PDF zurückgibt. diff --git a/build/classes/.DS_Store b/build/classes/.DS_Store new file mode 100644 index 0000000..e82e312 Binary files /dev/null and b/build/classes/.DS_Store differ diff --git a/build/classes/systems/.DS_Store b/build/classes/systems/.DS_Store new file mode 100644 index 0000000..9763b26 Binary files /dev/null and b/build/classes/systems/.DS_Store differ diff --git a/build/classes/systems/sdw/.DS_Store b/build/classes/systems/sdw/.DS_Store new file mode 100644 index 0000000..8428398 Binary files /dev/null and b/build/classes/systems/sdw/.DS_Store differ diff --git a/build/classes/systems/sdw/Frontcontroller.class b/build/classes/systems/sdw/Frontcontroller.class new file mode 100644 index 0000000..d517bcd Binary files /dev/null and b/build/classes/systems/sdw/Frontcontroller.class differ diff --git a/build/classes/systems/sdw/Readertest.class b/build/classes/systems/sdw/Readertest.class new file mode 100644 index 0000000..46ec061 Binary files /dev/null and b/build/classes/systems/sdw/Readertest.class differ diff --git a/build/classes/systems/sdw/ZugferdUtil.class b/build/classes/systems/sdw/ZugferdUtil.class new file mode 100644 index 0000000..4924724 Binary files /dev/null and b/build/classes/systems/sdw/ZugferdUtil.class differ diff --git a/build/classes/systems/sdw/baseapps/Protokoll$TSRange.class b/build/classes/systems/sdw/baseapps/Protokoll$TSRange.class new file mode 100644 index 0000000..628278f Binary files /dev/null and b/build/classes/systems/sdw/baseapps/Protokoll$TSRange.class differ diff --git a/build/classes/systems/sdw/baseapps/Protokoll.class b/build/classes/systems/sdw/baseapps/Protokoll.class new file mode 100644 index 0000000..16757ab Binary files /dev/null and b/build/classes/systems/sdw/baseapps/Protokoll.class differ diff --git a/build/classes/systems/sdw/baseapps/TYPE.class b/build/classes/systems/sdw/baseapps/TYPE.class new file mode 100644 index 0000000..6699a08 Binary files /dev/null and b/build/classes/systems/sdw/baseapps/TYPE.class differ diff --git a/build/classes/systems/sdw/basetech/.DS_Store b/build/classes/systems/sdw/basetech/.DS_Store new file mode 100644 index 0000000..e274956 Binary files /dev/null and b/build/classes/systems/sdw/basetech/.DS_Store differ diff --git a/build/classes/systems/sdw/basetech/json/CDL.class b/build/classes/systems/sdw/basetech/json/CDL.class new file mode 100644 index 0000000..d36c1bf Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/CDL.class differ diff --git a/build/classes/systems/sdw/basetech/json/Cookie.class b/build/classes/systems/sdw/basetech/json/Cookie.class new file mode 100644 index 0000000..806267d Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/Cookie.class differ diff --git a/build/classes/systems/sdw/basetech/json/CookieList.class b/build/classes/systems/sdw/basetech/json/CookieList.class new file mode 100644 index 0000000..4acd384 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/CookieList.class differ diff --git a/build/classes/systems/sdw/basetech/json/HTTP.class b/build/classes/systems/sdw/basetech/json/HTTP.class new file mode 100644 index 0000000..68390f7 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/HTTP.class differ diff --git a/build/classes/systems/sdw/basetech/json/HTTPTokener.class b/build/classes/systems/sdw/basetech/json/HTTPTokener.class new file mode 100644 index 0000000..44001ff Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/HTTPTokener.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONArray.class b/build/classes/systems/sdw/basetech/json/JSONArray.class new file mode 100644 index 0000000..d8c1c5c Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONArray.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONException.class b/build/classes/systems/sdw/basetech/json/JSONException.class new file mode 100644 index 0000000..2b6e7ab Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONException.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONML.class b/build/classes/systems/sdw/basetech/json/JSONML.class new file mode 100644 index 0000000..ef36345 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONML.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONObject$Null.class b/build/classes/systems/sdw/basetech/json/JSONObject$Null.class new file mode 100644 index 0000000..5b6d4c2 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONObject$Null.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONObject.class b/build/classes/systems/sdw/basetech/json/JSONObject.class new file mode 100644 index 0000000..a36c33a Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONObject.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONString.class b/build/classes/systems/sdw/basetech/json/JSONString.class new file mode 100644 index 0000000..0d283f1 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONString.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONStringer.class b/build/classes/systems/sdw/basetech/json/JSONStringer.class new file mode 100644 index 0000000..8cb4108 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONStringer.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONTokener.class b/build/classes/systems/sdw/basetech/json/JSONTokener.class new file mode 100644 index 0000000..faab03e Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONTokener.class differ diff --git a/build/classes/systems/sdw/basetech/json/JSONWriter.class b/build/classes/systems/sdw/basetech/json/JSONWriter.class new file mode 100644 index 0000000..1327e2c Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/JSONWriter.class differ diff --git a/build/classes/systems/sdw/basetech/json/Test$1Obj.class b/build/classes/systems/sdw/basetech/json/Test$1Obj.class new file mode 100644 index 0000000..2d7408a Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/Test$1Obj.class differ diff --git a/build/classes/systems/sdw/basetech/json/Test.class b/build/classes/systems/sdw/basetech/json/Test.class new file mode 100644 index 0000000..d58c5c8 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/Test.class differ diff --git a/build/classes/systems/sdw/basetech/json/XML.class b/build/classes/systems/sdw/basetech/json/XML.class new file mode 100644 index 0000000..d0cae5c Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/XML.class differ diff --git a/build/classes/systems/sdw/basetech/json/XMLTokener.class b/build/classes/systems/sdw/basetech/json/XMLTokener.class new file mode 100644 index 0000000..0eeef45 Binary files /dev/null and b/build/classes/systems/sdw/basetech/json/XMLTokener.class differ diff --git a/src/.DS_Store b/src/.DS_Store new file mode 100644 index 0000000..54a5e4e Binary files /dev/null and b/src/.DS_Store differ diff --git a/src/main/.DS_Store b/src/main/.DS_Store new file mode 100644 index 0000000..1278a55 Binary files /dev/null and b/src/main/.DS_Store differ diff --git a/src/main/java/.DS_Store b/src/main/java/.DS_Store new file mode 100644 index 0000000..e82e312 Binary files /dev/null and b/src/main/java/.DS_Store differ diff --git a/src/main/java/systems/.DS_Store b/src/main/java/systems/.DS_Store new file mode 100644 index 0000000..9763b26 Binary files /dev/null and b/src/main/java/systems/.DS_Store differ diff --git a/src/main/java/systems/sdw/.DS_Store b/src/main/java/systems/sdw/.DS_Store new file mode 100644 index 0000000..8428398 Binary files /dev/null and b/src/main/java/systems/sdw/.DS_Store differ diff --git a/src/main/java/systems/sdw/Frontcontroller.java b/src/main/java/systems/sdw/Frontcontroller.java new file mode 100644 index 0000000..eef0c3c --- /dev/null +++ b/src/main/java/systems/sdw/Frontcontroller.java @@ -0,0 +1,249 @@ +package systems.sdw; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; +import java.math.BigDecimal; +import java.util.Collection; +import java.util.Date; +import java.util.Iterator; +import java.util.Properties; +import java.util.UUID; + +import javax.servlet.ServletConfig; +import javax.servlet.ServletContext; +import javax.servlet.ServletException; +import javax.servlet.annotation.MultipartConfig; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.servlet.http.HttpSession; +import javax.servlet.http.Part; + +import org.apache.pdfbox.Loader; +import org.apache.pdfbox.pdmodel.PDDocument; +import org.apache.pdfbox.pdmodel.PDPage; +import org.apache.pdfbox.pdmodel.PDPageContentStream; +import org.apache.pdfbox.pdmodel.common.PDRectangle; +import org.apache.pdfbox.pdmodel.font.PDType1Font; +import org.apache.pdfbox.pdmodel.font.Standard14Fonts; +import org.mustangproject.BankDetails; +import org.mustangproject.Contact; +import org.mustangproject.Invoice; +import org.mustangproject.Item; +import org.mustangproject.Product; +import org.mustangproject.TradeParty; +import org.mustangproject.ZUGFeRD.PDFAConformanceLevel; +import org.mustangproject.ZUGFeRD.ZUGFeRDExporterFromA3; +import org.mustangproject.ZUGFeRD.ZUGFeRDImporter; + +import systems.sdw.basetech.json.JSONArray; +import systems.sdw.basetech.json.JSONException; +import systems.sdw.basetech.json.JSONObject; + +// @WebServlet("/fc") +@MultipartConfig ( + //location= "/Users/benediktwismans/tmp", + location= "/tmp", + fileSizeThreshold = 1024, + maxFileSize = 1024*1024*10, + maxRequestSize = 1024*1024 + ) + +public class Frontcontroller extends HttpServlet { + + private static final long serialVersionUID = 1L; + + private static final String encodingUTF8="UTF-8"; + private static final String tmpDir="tmpdir"; + private static final String dmsDir="dmsdir"; + private static final String debug="debug"; + + private static Properties propsSystem = new Properties(); + + + + public void init(ServletConfig servletconfig) throws ServletException { + System.out.println("ZFD SDW Frontcontroller ->INIT"); + // + super.init(servletconfig); + // + ServletContext context=getServletContext(); + propsSystem.setProperty(tmpDir, context.getInitParameter("system.defaults.tmpPath")); + propsSystem.setProperty(dmsDir, context.getInitParameter("system.defaults.dmsPath")); + propsSystem.setProperty(debug, context.getInitParameter("system.debug")); + propsSystem.list(System.out); + // + System.out.println("ZFD SDW Frontcontroller <-INIT"); + } + + @SuppressWarnings("unused") + private void debugInfo(HttpServletRequest request) throws IOException, ServletException { + // + String contenttyp = request.getContentType(); + System.out.println("CONTENTTYPE "+contenttyp); + + Collection parts=request.getParts(); + Iterator it=parts.iterator(); + + while (it.hasNext()) { + Part part=it.next(); + System.out.println(""); + System.out.println("NAME " + part.getName()); + System.out.println("SIZE " + part.getSize()); + System.out.println("FILE " + part.getSubmittedFileName()); + System.out.println("TYPE " + part.getContentType()); + } + } + + + protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + System.out.println("ZFD SDW doPost ->INIT"); + // + HttpSession session=request.getSession(true); + String sessionid=session.getId().toString(); + // + try { + request.setCharacterEncoding(encodingUTF8); + } catch (UnsupportedEncodingException e1) { + e1.printStackTrace(); + } + + if ("true"==propsSystem.getProperty(debug, "false")) debugInfo(request); + + // PDF + File pdf=processPDF(request, sessionid); + + // JSON + JSONObject json=processJSON(request); + + File targetFile=ZugferdUtil.createZugferdPDF(pdf, json); + + // Response + if (targetFile!=null) { + processResponse(response, targetFile, targetFile.getName()); + } else { + processResponse(response, pdf, pdf.getName()); + } + // + System.out.println("ZFD SDW doPost <-INIT"); + } + + + private static JSONObject processJSON(HttpServletRequest request) throws IOException, ServletException { + + Part jsonPart=request.getPart("rechnung_json"); + + ByteArrayOutputStream out=new ByteArrayOutputStream(); + InputStream in=jsonPart.getInputStream(); + + byte[] buffer = new byte[1024]; + for (int length; (length = in.read(buffer)) != -1; ) out.write(buffer, 0, length); + + try { + return new JSONObject(out.toString(encodingUTF8)); + } catch (UnsupportedEncodingException e) { + e.printStackTrace(); + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + + private static File processPDF(HttpServletRequest request, String sessionid) throws IOException, ServletException { + + Part pdfPart=request.getPart("rechnung_pdf"); + + try { + //File file=new File("/Users/benediktwismans/tmp", sessionid+"_"+pdfPart.getSubmittedFileName()); + File file=new File("/tmp/"+UUID.randomUUID()); + FileOutputStream out=new FileOutputStream(file); + InputStream in = pdfPart.getInputStream(); + byte[] buf = new byte[1024]; int nread = 0, total_read = 0; + + while (-1 != (nread = in.read(buf))) { + total_read += nread; + out.write(buf, 0, nread); + } + out.close(); + in.close(); + System.out.println("\n"+getLogPrefix(sessionid)+" ZFD fc "+pdfPart.getName()+" to "+file.getAbsolutePath() + " BYTES: " + total_read); + return file; + + } + catch (FileNotFoundException e) { + e.printStackTrace(); + } + catch (IOException e) { + e.printStackTrace(); + } + return null; + } + + + private static void processResponse (HttpServletResponse response, java.io.File file, String filename) throws IOException { + // + response.setHeader("Cache-Control", "no-cache"); // HTTP 1.1 + response.setHeader("Pragma", "no-cache"); // HTTP 1.0 + response.setDateHeader("Expires", 0); // Kein Proxy-Caching + response.setCharacterEncoding(encodingUTF8); + response.setContentType("application/pdf"); + + // + // Das Dokument in den Servletresponse schreiben + // + if (file==null) System.out.print(" error: file is null "); + else if (!file.exists()) System.out.print(" error: "+file.getCanonicalPath()+" not found"); + else { + int bytes=Long.valueOf(file.length()).intValue(); + java.io.FileInputStream in=new java.io.FileInputStream(file); + + byte[] content=new byte[bytes]; + bytes=in.read(content); + response.setContentLength(content.length); + System.out.println("SDW Download: Bytes:" +bytes); + + //response.setHeader("Content-disposition", "inline; filename=\""+filename+"\""); + response.setHeader("Content-disposition", "attachment; filename=\""+filename+"\""); + + response.getOutputStream().write(content); + response.getOutputStream().flush(); + response.getOutputStream().close(); + + in.close(); + } + } + + private static String getLogPrefix(String sessionid) { + return new java.text.SimpleDateFormat("dd.MM.yyyy HH:mm:ss ").format(new java.util.Date())+Frontcontroller.class.getCanonicalName()+" "+sessionid+" "; + } + + public void destroy() { + } + + protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException { + processGetRequest(request, response); + } + + private void processGetRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException { + throw new ServletException("GET-Request wird von SDW ZFD fc nicht behandelt"); + } + +} + + + + + + + + + + + diff --git a/src/main/java/systems/sdw/Readertest.java b/src/main/java/systems/sdw/Readertest.java new file mode 100644 index 0000000..92d2e9c --- /dev/null +++ b/src/main/java/systems/sdw/Readertest.java @@ -0,0 +1,108 @@ +package systems.sdw; + +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.util.Date; + +import org.apache.pdfbox.Loader; +import org.apache.pdfbox.pdmodel.PDDocument; +import org.apache.pdfbox.pdmodel.PDPage; +import org.apache.pdfbox.pdmodel.PDPageContentStream; +import org.apache.pdfbox.pdmodel.common.PDRectangle; +import org.apache.pdfbox.pdmodel.font.PDType1Font; +import org.apache.pdfbox.pdmodel.font.Standard14Fonts; +import org.mustangproject.BankDetails; +import org.mustangproject.Contact; +import org.mustangproject.Invoice; +import org.mustangproject.Item; +import org.mustangproject.Product; +import org.mustangproject.TradeParty; +import org.mustangproject.ZUGFeRD.IZUGFeRDExporter; +import org.mustangproject.ZUGFeRD.ZUGFeRDExporterFromA1; +import org.mustangproject.ZUGFeRD.ZUGFeRDExporterFromA3; +import org.mustangproject.ZUGFeRD.ZUGFeRDExporterFromPDFA; +import org.mustangproject.ZUGFeRD.ZUGFeRDImporter; + +public class Readertest { + + public static void main(String[] args) { + + File pdf=new File("/Users/benediktwismans/tmp/73788e01-e5ff-440b-877c-f3b7c4f937ff.pdf"); + + try { + checkZugferdDaten(pdf); + } catch (IOException e) { + e.printStackTrace(); + } + } + + + + + private static void write(PDPageContentStream contentStream, int textx, int texty, String text) throws IOException { + + contentStream.beginText(); + contentStream.setFont(new PDType1Font(Standard14Fonts.FontName.COURIER), 12); + + contentStream.newLineAtOffset(textx,texty); + contentStream.showText(text); + contentStream.endText(); + } + + + + + private static void checkZugferdDaten(File pdf) throws IOException { + + ZUGFeRDImporter zi=new ZUGFeRDImporter(pdf.getCanonicalPath()); + + System.out.println("getTaxTotalAmount " + zi.getTaxTotalAmount()); + System.out.println("getLineTotalAmount " + zi.getLineTotalAmount()); + + System.out.println("getIBAN " + zi.getIBAN()); + System.out.println("getBIC " + zi.getBIC()); + System.out.println("getAmount " + zi.getAmount()); + + System.out.println("getDueDate " + zi.getDueDate()); + System.out.println("getInvoiceCurrencyCode " + zi.getInvoiceCurrencyCode()); + System.out.println("getInvoiceID " + zi.getInvoiceID()); + + + PDDocument doc = Loader.loadPDF(pdf); + PDPage page = new PDPage(PDRectangle.A4); + doc.addPage(page); + + PDPageContentStream contentStream = new PDPageContentStream(doc, page); + + write(contentStream, 30,750, "Diese Rechnung im PDF-Format enthält einen maschinenlesbaren Teil, der"); + write(contentStream, 30,735, "dem ZUGFeRD-Standard Version 2 entspricht."); + + write(contentStream, 30,720, "Diese Seite, die nicht zur Rechnung gehört, dient dazu, die Integrität"); + write(contentStream, 30,705, "dieser Daten zu dokumentieren. Dazu wurden die relevantesten Daten "); + write(contentStream, 30,690, "NACH dem Hinzufügen zu diesem PDF-Dokument wieder ausgelesen und"); + write(contentStream, 30,675, "sind im folgenden aufgeführt."); + + + write(contentStream, 100,600, "getInvoiceID " + zi.getInvoiceID()); + write(contentStream, 100,580, "getInvoiceCurrencyCode " + zi.getInvoiceCurrencyCode()); + write(contentStream, 100,560, "getDueDate " + zi.getDueDate()); + write(contentStream, 100,540, "getIBAN " + zi.getIBAN() ); + write(contentStream, 100,520, "getBIC " + zi.getBIC()); + write(contentStream, 100,500, "getLineTotalAmount " + zi.getLineTotalAmount()); + write(contentStream, 100,480, "getTaxTotalAmount " + zi.getTaxTotalAmount()); + write(contentStream, 100,460, "getAmount " + zi.getAmount()); + + contentStream.close(); + + doc.save(pdf); + + } + + + + + + + +} diff --git a/src/main/java/systems/sdw/ZugferdUtil.java b/src/main/java/systems/sdw/ZugferdUtil.java new file mode 100644 index 0000000..71d6aa2 --- /dev/null +++ b/src/main/java/systems/sdw/ZugferdUtil.java @@ -0,0 +1,223 @@ +package systems.sdw; + +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; +import java.util.UUID; + +import org.apache.pdfbox.Loader; +import org.apache.pdfbox.pdmodel.PDDocument; +import org.apache.pdfbox.pdmodel.PDPage; +import org.apache.pdfbox.pdmodel.PDPageContentStream; +import org.apache.pdfbox.pdmodel.common.PDRectangle; +import org.apache.pdfbox.pdmodel.font.PDType1Font; +import org.apache.pdfbox.pdmodel.font.Standard14Fonts; +import org.mustangproject.BankDetails; +import org.mustangproject.Contact; +import org.mustangproject.Invoice; +import org.mustangproject.Item; +import org.mustangproject.Product; +import org.mustangproject.TradeParty; +import org.mustangproject.ZUGFeRD.ZUGFeRDExporterFromA3; +import org.mustangproject.ZUGFeRD.ZUGFeRDImporter; + +import systems.sdw.basetech.json.JSONArray; +import systems.sdw.basetech.json.JSONException; +import systems.sdw.basetech.json.JSONObject; + +public class ZugferdUtil { + + + public static void main(String[] args) throws IOException, JSONException{ + + String originalPath="/Users/benediktwismans/tmp/rechnung_sdw.2025.06241.pdf"; + //String originalPath="/Users/benediktwismans/tmp/rechnung_sdw.2025.06234.pdf"; + + String copyPath="/Users/benediktwismans/tmp/zugferd.pdf"; + Files.copy(Path.of(originalPath), Path.of(copyPath), StandardCopyOption.REPLACE_EXISTING); + + // PDF + File pdf=new File(copyPath); + + // JSON + String content = Files.readString(Path.of("/Users/benediktwismans/tmp/sdw.json"), Charset.forName("UTF-8")); + // String content = Files.readString(Path.of("/Users/benediktwismans/tmp/zugferd.json"), Charset.forName("UTF-8")); + JSONObject json=new JSONObject(content); + System.out.println(json.toString(3)); + + createZugferdPDF(pdf, json); + + } + + public static File createZugferdPDF(File pdf, JSONObject json) { + + if (pdf!=null && json!=null) { + + try { + // A1 und PDFA funktionieren nicht. + ZUGFeRDExporterFromA3 ze=new ZUGFeRDExporterFromA3().load(pdf.getCanonicalPath()); + + ze.setProducer("SDW Bischberg Dipl.Wirtsch.-Inf. Benedikt Wismans"); + ze.setCreator("Benedikt Wismans"); + +// ze.setZUGFeRDVersion(2); +// ze.setConformanceLevel(PDFAConformanceLevel.UNICODE); + + /* + * Mustangproject checks if the input PDF/A file looks halfway valid and + * the XML data contains ]*>", ""); + } + + + /** + * Wird insbesonderee bei den Piechart-Labeln verwendet, die können nicht mit UTF-8 umgehen. + */ + private static String[][] UMLAUT_REPLACEMENTS = { { "Ä", "Ae" }, { "Ü", "Ue" }, { "Ö", "Oe" }, { "ä", "ae" }, { "ü", "ue" }, { "ö", "oe" }, { "ß", "ss" }, { "-", "" } }; + public static String replaceUmlaute(String orig) { + String result = orig; + + for (int i = 0; i < UMLAUT_REPLACEMENTS.length; i++) { + result = result.replaceAll(UMLAUT_REPLACEMENTS[i][0], UMLAUT_REPLACEMENTS[i][1]); + } + return result; + } + + /** + * Entfernt alle potentiell problematischen Zeichen aus dem String + * @param string + * @return + */ + public static String string2JsonCompatibleString(String string) { + String result=""; + if (string!=null) result=string.replace("\n", " ").replace("\r", " ").replace("\t", " ").replace("null", "").replace("\"", "'").replace(",", " ").trim(); + return result; + } + + public static String getTimestamp() { + return new java.text.SimpleDateFormat("dd.MM.yyyy-HH.mm.ss").format(new java.util.Date()); + } + + public static String getTimestampMilliNoDots(java.util.Date date) { + return new java.text.SimpleDateFormat("dd-MM-yyyy-HH-mm-ss-SSS").format(date); + } + + public static String getTimestampMilli(java.util.Date date) { + return new java.text.SimpleDateFormat("dd.MM.yyyy-HH.mm.ss.SSS").format(date); + } + public static String getTimestampMilli() { + return getTimestampMilli(new java.util.Date()); + } + + public static Boolean getBoolean(JSONObject jsonData, String jsonTag, Boolean currentValue, boolean defaultValue) { + return jsonData.getBoolean(jsonTag, currentValue, defaultValue); + } + + public static Double getDouble(JSONObject jsonData, String jsonTag, Double currentValue, Double defaultValue) { + Double value=currentValue; + try {value=jsonData.getDouble(jsonTag);}catch (JSONException ignored) {} + if (value==null) value=defaultValue; + return value; + } + + + public static Integer getInteger(JSONObject jsonData, String jsonTag, Integer currentValue, Integer defaultValue) { + Integer value=currentValue; + try {value=jsonData.getInteger(jsonTag);}catch (JSONException ignored) {} + if (value==null) value=defaultValue; + return value; + } + + public static Long getLong(JSONObject jsonData, String jsonTag, Long currentValue, Long defaultValue) { + Long value=currentValue; + try {value=jsonData.getLong(jsonTag);}catch (JSONException ignored) {} + if (value==null) value=defaultValue; + return value; + } + + public static String getString(JSONObject jsonData, String jsonTag, String currentValue) { + return getString(jsonData, jsonTag, currentValue, ""); + } + + /** + * Der default-Value wird auch gesetzt wenn der String nicht null aber leer ist. + * @param jsonData + * @param jsonTag + * @param currentValue + * @param defaultValue + * @return + */ + public static String getStringNotEmpty(JSONObject jsonData, String jsonTag, String currentValue, String defaultValue) { + String value=currentValue; + if (currentValue==null || currentValue=="") value=defaultValue; + try {value=jsonData.getString(jsonTag);}catch (JSONException ignored) {} + if (value==null || value=="") value=defaultValue; + return value; + } + + public static String getString(JSONObject jsonData, String jsonTag, String currentValue, String defaultValue) { + String value=currentValue; + if (currentValue==null) value=defaultValue; + try { + value=jsonData.getString2(jsonTag); + }catch (JSONException e) { + //e.printStackTrace(); + } + return value; + } + + public static String getBeschreibung(JSONObject jsonData, String currentValue) { + String value=(currentValue!=null && currentValue.length()>0) ? currentValue : null; + try {value=jsonData.getString(Protokoll.beschreibung);}catch (JSONException ignored) {} + return value; + } + + public static String getName(JSONObject jsonData, String defaultValue) { + String value=(defaultValue!=null) ? defaultValue : ""; + try {value=jsonData.getString(Protokoll.name);}catch (JSONException ignored) {} + return value; + } + + static public boolean checkParam(String buf) { + if (buf==null) return false; + if (buf.length()==0) return false; + if (buf.equals("null")) return false; + if (buf.equals("undefined")) return false; + return true; + } + + public static String getParameterDecoded( HttpServletRequest request, String buf ) { + + String sValue=new String(); + + try { + // + String sQueryString=java.net.URLDecoder.decode(request.getQueryString(),Protokoll.encodingDefault); + + int nStartPos=sQueryString.indexOf(buf)+buf.length()+1; + int nEndPos=sQueryString.indexOf("&",nStartPos); + + if ( nEndPos<0) { + // nach dem gesuchten Wert kommt kein anderer Wert mehr, also den gesamten Reststring zurueckgeben + nEndPos=sQueryString.length(); + } + sValue=sQueryString.substring(nStartPos,nEndPos); + } + catch (java.io.UnsupportedEncodingException e) { + System.out.print(" URL fehlerhaft"); + } + return sValue; + } + + + + public static class TSRange { + public Timestamp von=null; + public Timestamp bis=null; + + public TSRange() {;} + public TSRange(Timestamp zeitpunkt) { + this.von=zeitpunkt; + this.bis=zeitpunkt; + } + public TSRange(Timestamp von, Timestamp bis) {this.von=von; this.bis=bis;} + } + + + + +} diff --git a/src/main/java/systems/sdw/baseapps/TYPE.java b/src/main/java/systems/sdw/baseapps/TYPE.java new file mode 100644 index 0000000..d8d77f4 --- /dev/null +++ b/src/main/java/systems/sdw/baseapps/TYPE.java @@ -0,0 +1,1506 @@ +package systems.sdw.baseapps; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.text.DateFormat; +import java.text.NumberFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.LocalDateTime; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; + +import systems.sdw.baseapps.Protokoll; +import systems.sdw.basetech.json.JSONException; +import systems.sdw.basetech.json.JSONObject; + + +public class TYPE { + + public static final String timeStampFormatDayDateTime = "EE dd.MM.yyyy HH:mm"; + public static final String dateFormatDayDateTime = "EE dd.MM.yyyy"; + public static final String timeFormatDayDateTime = "HH:mm"; + + public final static String timeStampFormatFull_EN="EEE MMM dd HH:mm:ss zzz yyyy"; + public final static String timeStampFormatFull_DE="EE dd. MMM HH:mm:ss zzz yyyy"; + + + public final static String patternISOFull = "yyyy-MM-dd'T'HH:mm:ss.SSS"; + public final static String patternISONoMillis= "yyyy-MM-dd'T'HH:mm:ss"; + + public static final Date infinityDate = new Date(9223372036825200000L); + public static final String infinityTimestamp="292278994-08-17 00:00:00.0"; + + + + /** + * Experimentell Erzeugt Timstamps aus Linus-Logeinträgen + * @param tsString + * @param tsFormat + * @return + */ + static public Timestamp ISOString2TimestampFull(String tsString, SimpleDateFormat tsFormat) { + + Calendar cal=Calendar.getInstance(); + cal.clear(); + + LocalDateTime ldt; + try { + // Erst die englische Version testen + ldt = ZonedDateTime.parse(tsString, DateTimeFormatter.ofPattern(timeStampFormatFull_EN, Locale.ENGLISH)).toLocalDateTime(); + + } catch(java.time.format.DateTimeParseException eDTPEEn) { + // Die Ausgabe von date gibt immer das englische Wort für die Zeitzone zurück, der Rest ist deutsch falls die locale gesetzt ist + tsString=tsString.replace("CEST", "MESZ"); + tsString=tsString.replace("CET", "MEZ"); + ldt = ZonedDateTime.parse(tsString, DateTimeFormatter.ofPattern(timeStampFormatFull_DE, Locale.GERMAN)).toLocalDateTime(); + } + cal.set(ldt.getYear(), ldt.getMonthValue()-1, ldt.getDayOfMonth()); + cal.set(Calendar.HOUR, ldt.getHour()); + cal.set(Calendar.MINUTE, ldt.getMinute()); + cal.set(Calendar.SECOND, ldt.getSecond()); + cal.set(Calendar.MILLISECOND, 0); + return new java.sql.Timestamp(cal.getTimeInMillis()); + } + + + + static public Date Cal2Date(Calendar cal) { + return new Date(cal.getTime().getTime()); + } + + static public Date getRootDate() { + Calendar cal=Calendar.getInstance(); + cal.set(2000, 0, 1); + return Cal2Date(cal); + } + + static public Date getExcelRootDate() { + Calendar cal=Calendar.getInstance(); + cal.set(1900, 0, 1); + return Cal2Date(cal); + } + + + static public Date getFinalDate() { + Calendar cal=Calendar.getInstance(); + cal.set(2999, 11, 31); + return Cal2Date(cal); + } + + static public String Decimal2String (Double nDouble, int nStellen) { + if(nDouble==null) return ""; + return Decimal2String(nDouble, nStellen, null); + } + + + public static String string2Listitem(String string) { + return "* "+string+"\n"; + } + + static public String Decimal2String (Double nDouble, int nStellen, Locale locale) { + + String sResult=new String(""); + + if (nDouble==null) return sResult; + else { + + java.text.DecimalFormat df=null; + + switch (nStellen) { + case 0: + df=new java.text.DecimalFormat( "###,##0" ); + break; + case 1: + df=new java.text.DecimalFormat( "###,##0.0" ); + break; + case 2: + df=new java.text.DecimalFormat( "###,##0.00" ); + break; + case 3: + df=new java.text.DecimalFormat( "###,##0.000" ); + break; + case 4: + df=new java.text.DecimalFormat( "###,##0.0000" ); + break; + default: // 1 Nachkommastelle + df=new java.text.DecimalFormat( "###,##0.0" ); + break; + } + if(locale != null) sResult= NumberFormat.getInstance(locale).format(df); + else sResult=df.format(nDouble); + } + return sResult; + + + + + } + + static public String Decimal2String (BigDecimal nDecimal, int nStellen) { + + String sResult=new String(""); + + if (nDecimal==null) return sResult; + else { + + java.text.DecimalFormat df=null; + + switch (nStellen) { + case 0: + df=new java.text.DecimalFormat( "###,##0" ); + break; + case 1: + df=new java.text.DecimalFormat( "###,##0.0" ); + break; + case 2: + df=new java.text.DecimalFormat( "###,##0.00" ); + break; + case 3: + df=new java.text.DecimalFormat( "###,##0.000" ); + break; + default: // 1 Nachkommastelle + df=new java.text.DecimalFormat( "###,##0.0" ); + break; + } + sResult=df.format(nDecimal); + } + return sResult; + } + + + static public String getWaehrungszeichen(String sWaehrungId) { + + String sZeichen=new String(); + int nWaehrungId=Integer.valueOf(sWaehrungId).intValue(); + switch (nWaehrungId) { + case 1: + sZeichen="€"; + break; + case 2: + sZeichen="DM"; + break; + case 3: + sZeichen="BF"; + break; + case 4: + sZeichen="FF"; + break; + case 5: + sZeichen="HFL"; + break; + case 6: + sZeichen="Peseta"; + break; + case 7: + sZeichen="SKK"; + break; + } + + return sZeichen; + } + + + static public String String2Searchstring(String vorname, String mittelname, String nachname) { + + StringBuffer buf=new StringBuffer(); + if (nachname!=null && nachname.length()>0) buf.append(nachname); + if (mittelname!=null && mittelname.length()>0) buf.append(mittelname); + if (vorname!=null && vorname.length()>0) buf.append(vorname); + + String s=buf.toString(); + if (s!=null && s.length()>0) { + s=s.toLowerCase(); + s=s.replace("ä", "ae"); + s=s.replace("ü", "ue"); + s=s.replace("ö", "oe"); + s=s.replace("ß", "ss"); + s=s.replace(".", ""); + s=s.replace(",", ""); + s=s.replace("_", ""); + s=s.replace("-", ""); + s=s.replace(";", ""); + } + + return s; + } + + static public String String2mailadress(String s) { + s=s.toLowerCase(); + if (s!=null && s.length()>0) { + s=s.toLowerCase(); + s=s.replace("ä", "ae"); + s=s.replace("ü", "ue"); + s=s.replace("ö", "oe"); + s=s.replace("ß", "ss"); + s=s.replace(" ", "."); + + } + return s; + } + + + static public Date String2Date (String date) { + + if (date==null) return null; + + // Excel/CSV sind Ganzzahlen, die am 01.01.1900 -2 Tage starten + try { + Integer exceldate=Integer.parseInt(date); + + // https://stackoverflow.com/questions/19028192/converting-number-representing-a-date-in-excel-to-a-java-date-object + // + Calendar cal=Calendar.getInstance(); + cal.set(Calendar.YEAR, 1899); + cal.set(Calendar.MONTH, 11); + cal.set(Calendar.DAY_OF_MONTH, 30); + // + cal.add(Calendar.DAY_OF_MONTH, exceldate); + // + return new Date(cal.getTime().getTime()); + + } catch (NumberFormatException eNoNumber) { + ; + } + + if (date.length()!=10) return null; + + + Calendar cal=Calendar.getInstance(); + cal.set(Calendar.DAY_OF_MONTH, Integer.valueOf(date.substring(0, 2)).intValue()); + cal.set(Calendar.MONTH, Integer.valueOf(date.substring(3, 5)).intValue()-1); + cal.set(Calendar.YEAR, Integer.valueOf(date.substring(6, 10)).intValue()); + + return new Date (cal.getTime().getTime()); + } + + + static public Timestamp String2Timestamp (String buf) { + + System.out.print(buf); + if (buf==null) return null; + if (buf=="") return null; + + Calendar cal=Calendar.getInstance(); + + cal.set(Calendar.DAY_OF_MONTH, Integer.valueOf(buf.substring(0, 2)).intValue()); + cal.set(Calendar.MONTH, Integer.valueOf(buf.substring(3, 5)).intValue()-1); + cal.set(Calendar.YEAR, Integer.valueOf(buf.substring(6, 10)).intValue()); + + cal.set(Calendar.HOUR_OF_DAY, Integer.valueOf(buf.substring(11, 13)).intValue()); + cal.set(Calendar.MINUTE, Integer.valueOf(buf.substring(14, 16)).intValue()); + cal.set(Calendar.SECOND, Integer.valueOf(buf.substring(17, 19)).intValue()); + + return new Timestamp (cal.getTime().getTime()); + } + + + static public Date getErsterVormonat() { + + Calendar cal=Calendar.getInstance(); + + cal.set(Calendar.HOUR_OF_DAY, 0); + cal.set(Calendar.MINUTE, 0); + cal.set(Calendar.SECOND, 0); + cal.set(Calendar.MILLISECOND, 0); + + cal.set(Calendar.DAY_OF_MONTH, 1); + cal.set(Calendar.MONTH, cal.get(Calendar.MONTH)-1); + + return new Date (cal.getTime().getTime()); + } + + static public Date getLetzterVorvormonat() { + + Calendar cal=Calendar.getInstance(); + + cal.set(Calendar.HOUR_OF_DAY, 0); + cal.set(Calendar.MINUTE, 0); + cal.set(Calendar.SECOND, 0); + cal.set(Calendar.MILLISECOND, 0); + + cal.set(Calendar.DAY_OF_MONTH, 1); + cal.set(Calendar.MONTH, cal.get(Calendar.MONTH)-1); + cal.set(Calendar.DAY_OF_MONTH, 0); + + return new Date (cal.getTime().getTime()); + } + + + + static public Date AmericanString2Date (String date) { + + if (date==null) return null; + if (date.length()!=8) return null; + + Calendar cal=Calendar.getInstance(); + cal.set(Calendar.DAY_OF_MONTH, Integer.valueOf(date.substring(6, 8)).intValue()); + cal.set(Calendar.MONTH, Integer.valueOf(date.substring(4, 6)).intValue()-1); + cal.set(Calendar.YEAR, Integer.valueOf(date.substring(0, 4)).intValue()); + + return new Date (cal.getTime().getTime()); + } + + + static public String String2String (String value) { + if (value==null||value.equalsIgnoreCase("null")) return ""; + else return value; + } + + static public boolean Long2Boolean(Long n) { + if (n.intValue()==1) return true; + else return false; + } + + + static public String Boolean2String(Boolean oBoolean) { + String sBoolean="nein"; + if ((oBoolean!=null)&&(oBoolean.booleanValue()==true)) sBoolean="ja"; + return sBoolean; + } + /** + * Returns String with Format "dd.MM.yyyy" + * @param date + * @return + */ + static public String Date2String (Date date) { + if (date!=null) return new java.text.SimpleDateFormat("dd.MM.yyyy").format(date); + else return ""; + } + + static public String Date2StringFull (Date date) { + if (date!=null) return new java.text.SimpleDateFormat("EEE dd.MM.yyyy").format(date); + else return ""; + } + + static public String Date2FileDate (Date date) { + if (date!=null) return new java.text.SimpleDateFormat("yyyy_MM_dd").format(date); + else return ""; + } + + /** + * Bei Ranges von einem Tag gibt es das Datum des Tages zurück, bei mehrtätigen wird der String in folgendem Format erzeugt: + * Fr. 26.01.2018 bis Mo 31.01.2018 (5 Tage) + * @param von + * @param bis + * @return + */ + static public String Date2StringFull (Date von, Date bis) { + if(von == null && bis == null) return ""; + if(bis == null || bis.equals(infinityDate)) return Date2StringFull(von)+" bis unbegrenzt"; + + int tage = getDaysBetween(von, bis); + + if (tage == 0) return Date2StringFull(von); + return Date2StringFull(von) +" bis "+ Date2StringFull(bis) +" ("+(tage+1)+" Tage)"; + } + + /** + * Timerange als pretty printed String + * @param von + * @param bis + * @return + */ + static public String Time2StringFull (Time von, Time bis) { + if(von == null && bis == null) return ""; + if(bis == null) return Time2String(von); + return Time2String(von)+" bis "+ Time2String(bis); + } + + /** + * Return an ISO 8601 combined date and time string for specified date/time + * + * @param timestamp + * @return String with format "yyyy-MM-dd'T'HH:mm:ss'Z'" + */ + + public static boolean isInfinity(Timestamp timestamp) { + return timestamp.toString().equals(infinityTimestamp); + } + + public static String Timestamp2ISO8601String(Timestamp timestamp) { + if (timestamp==null) return ""; + if (timestamp.toString().equals(infinityTimestamp)) return ""; + DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); + return dateFormat.format(timestamp); + } + + + public static String Timestamp2ISO8601StringUTC(Timestamp timestamp) { + if (timestamp==null) return ""; + if (timestamp.toString().equals(infinityTimestamp)) return ""; + DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); + dateFormat.setTimeZone(TimeZone.getTimeZone("UTC")); + return dateFormat.format(timestamp); + } + + public static String Timestamp2ISO8601String(Timestamp timestamp, String formatstring) { + if (timestamp==null || timestamp.toString().equals(infinityTimestamp)) return ""; + DateFormat dateFormat = new SimpleDateFormat(formatstring); + return dateFormat.format(timestamp); + } + + + public static String Date2ISO8601String(Date date) { + if (date==null || date.equals(infinityDate)) return ""; + DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); + return dateFormat.format(date); + } + +// public static String Timestamp2ISO8601String(Date date) { +// if (date==null || date.equals(infinityDate)) return ""; +// DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"); +// return dateFormat.format(date); +// } + + + public static String Date2String(Date date, String formatstring) { + if (date==null || date.equals(infinityDate)) return ""; + if (formatstring==null) return Date2String(date); + DateFormat dateFormat = new SimpleDateFormat(formatstring); + return dateFormat.format(date); + } + + public static String Time2ISO8601String(Time time) { + if (time==null) return ""; + DateFormat dateFormat = new SimpleDateFormat("'T'HH:mm:ss"); + return dateFormat.format(time); + } + + + public static String getWeekday(Date date) { + if (date==null) return null; + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + switch (cal.get(Calendar.DAY_OF_WEEK)) { + case (Calendar.MONDAY): + return "Montag"; + case (Calendar.TUESDAY): + return "Dienstag"; + case (Calendar.WEDNESDAY): + return "Mittwoch"; + case (Calendar.THURSDAY): + return "Donnerstag"; + case (Calendar.FRIDAY): + return "Freitag"; + case (Calendar.SATURDAY): + return "Samstag"; + case (Calendar.SUNDAY): + return "Sonntag"; + default: return null; + } + } + + + public static Date ISO8601String2Date(String string) { + if (string==null || string.length()==0 || string.equalsIgnoreCase("null")) return null; + + try { + String pattern = "yyyy-MM-dd'T'HH:mm:ss'Z'"; + SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.GERMANY); + sdf.setTimeZone(TimeZone.getTimeZone("UTC+01:00")); + + Date date = new Date(sdf.parse(string).getTime()); + TimeZone ts = TimeZone.getTimeZone("CET"); + if(ts.inDaylightTime(date)) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + cal.add(Calendar.HOUR, 1); + date = new Date(date.getTime()); + } + return date; + } catch (ParseException e1) { + + try { + String pattern = "yyyy-MM-dd'T'HH:mm:ss"; + SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.GERMANY); + return new Date(sdf.parse(string).getTime()); + + } + catch (ParseException e2) { + + try { + String pattern = "yyyy-MM-dd"; + SimpleDateFormat sdf = new SimpleDateFormat(pattern); + return new Date(sdf.parse(string).getTime()); + } catch (ParseException e3) { + e2.printStackTrace(); + return null; + } + } + } + +// java.util.Date date = Date.from(java.time.ZonedDateTime.parse(string).toInstant()); +// return new Date(date.getTime()); + } + + + + public static Date ISO8601String2Date(String string, String pattern) { + if (string==null || string.length()==0 || string.equalsIgnoreCase("null")) return null; + + if (pattern==null) pattern=patternISOFull; + + try { + SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.GERMANY); + Date date = new Date(sdf.parse(string).getTime()); + return date; + } catch (ParseException e1) { + e1.printStackTrace(); + return null; + } + } + + public static Timestamp ISO8601String2Timestamp(String string, String pattern) { + if (string==null || string.length()==0) return null; + return new Timestamp(ISO8601String2Date(string, pattern).getTime()); + } + + + public static Timestamp ISO8601String2Timestamp(String string) { + if (string==null || string.length()==0) return null; + return new Timestamp(ISO8601String2Date(string).getTime()); + } + + + + public static Time ISO8601String2Time(String string) { + if (string==null || string.length()==0) return null; + if (string.length()==9) { + // T08:30:00 + string="1970-01-01"+string; + } + Date date = ISO8601String2Date(string); + if(date != null) return new Time(date.getTime()); + return null; + + } + + static public String Time2String (Time zeit) { + if (zeit!=null) return new java.text.SimpleDateFormat("HH:mm").format(zeit); + else return ""; + } + + + static public String Time2String (Time zeit, String formatstring) { + if (zeit!=null) return new java.text.SimpleDateFormat(formatstring).format(zeit); + else return ""; + } + + + static public Double getDiffHourTimestamp(Timestamp beginn, Timestamp ende, boolean ignoreSeconds) { + + if(ignoreSeconds) { + Calendar cBeginn = Calendar.getInstance(); + cBeginn.setTime(beginn); + cBeginn.set(Calendar.SECOND, 0); + cBeginn.set(Calendar.MILLISECOND, 0); + + Calendar cEnde = Calendar.getInstance(); + cEnde.setTime(ende); + cEnde.set(Calendar.SECOND, 0); + cEnde.set(Calendar.MILLISECOND, 0); + + return MillisToHour(cEnde.getTimeInMillis()-cBeginn.getTimeInMillis()); + } + + return MillisToHour(ende.getTime()-beginn.getTime()); + } + + static public Integer getDiffMinutesTimestamp(Timestamp beginn, Timestamp ende, boolean ignoreSeconds) { + + if(ignoreSeconds) { + Calendar cBeginn = Calendar.getInstance(); + cBeginn.setTime(beginn); + cBeginn.set(Calendar.SECOND, 0); + cBeginn.set(Calendar.MILLISECOND, 0); + + Calendar cEnde = Calendar.getInstance(); + cEnde.setTime(ende); + cEnde.set(Calendar.SECOND, 0); + cEnde.set(Calendar.MILLISECOND, 0); + + return MillisToMinute(cEnde.getTimeInMillis()-cBeginn.getTimeInMillis()); + } + + return MillisToMinute(ende.getTime()-beginn.getTime()); + } + + + static public Double MillisToHour(Long milliseconds) { + return milliseconds/1000.0/60.0/60.0; + + } + + static public Integer MillisToMinute(Long milliseconds) { + Double result = milliseconds/1000.0/60.0; + return result.intValue(); + } + + + static public Time String2Time (String zeit) { + DateFormat formatter = new SimpleDateFormat("HH:mm"); + Date time; + try { + time = new Date(formatter.parse(zeit).getTime()); + } catch (ParseException e) { + e.printStackTrace(); + return null; + } + return new Time(time.getTime()); + } + + +// static public Time String2Time (String date) { +// +// if (date==null) return null; +// if (date=="") return null; +// +// Calendar cal=Calendar.getInstance(); +// cal.set(Calendar.HOUR_OF_DAY, Integer.valueOf(date.substring(0, 2)).intValue()); +// cal.set(Calendar.MINUTE, Integer.valueOf(date.substring(3, 5)).intValue()); +// cal.set(Calendar.SECOND, Integer.valueOf(date.substring(6, 8)).intValue()); +// +// return new Time (cal.getTime().getTime()); +// } + + + static public java.sql.Date Timestamp2Date(Timestamp zeitstempel) { + if (zeitstempel==null) return null; + return new java.sql.Date(zeitstempel.getTime()); + } + + static public java.sql.Time Timestamp2Time(Timestamp zeitstempel) { + if (zeitstempel==null) return null; + return new java.sql.Time(zeitstempel.getTime()); + } + + static public String Timestamp2String (Timestamp zeitstempel) { + if (zeitstempel!=null) return new java.text.SimpleDateFormat("dd.MM.yyyy HH.mm.ss").format(zeitstempel); + else return ""; + } + + static public String Timestamp2StringTimeOnly (Timestamp zeitstempel) { + if (zeitstempel!=null) return new java.text.SimpleDateFormat("HH:mm").format(zeitstempel); + else return ""; + } + + static public String Timestamp2StringDateOnly (Timestamp zeitstempel) { + if (zeitstempel!=null) return new java.text.SimpleDateFormat("dd.MM.yyyy").format(zeitstempel); + else return ""; + } + + static public String Timestamp2StringFormatISO (Timestamp zeitstempel) { + if (zeitstempel!=null) return new java.text.SimpleDateFormat(timeStampFormatDayDateTime).format(zeitstempel); + else return ""; + } + + + static public String TimestampRange2String (Timestamp von, Timestamp bis) { + return TimestampRange2String(von, bis, null); + } + + /** + * Fall der Tag der gleiche ist wird das Datum nur einmal angegben + * @param von + * @param bis + * @param formatString + * @return + */ + static public String TimestampRange2String (Timestamp von, Timestamp bis, String formatString) { + if (von==null) return ""; + if (formatString==null) formatString=timeStampFormatDayDateTime; + + if (Timestamp2StringDateOnly(von).equals(Timestamp2StringDateOnly(bis))) { + return TYPE.Timestamp2String(von, formatString)+"-"+Timestamp2StringTimeOnly(bis); + } else { + return TYPE.Timestamp2String(von, formatString)+" - "+TYPE.Timestamp2String(bis, formatString); + } + } + + + static public String DateRange2String (Date von, Date bis) { + if (von==null) return ""; + + StringBuffer buf = new StringBuffer(TYPE.Date2String(von)); + if (bis==null || bis==TYPE.infinityDate) buf.append(" bis unbegrenzt"); + else buf.append(" bis "+TYPE.Date2String(bis)); + // + return buf.toString(); + } + + static public String TimeRange2String (Time von, Time bis) { + if (von==null) return ""; + + StringBuffer buf = new StringBuffer(TYPE.Time2String(von)); + if (bis==null) { + buf.append(" bis unbegrenzt"); + } + else buf.append(" bis "+TYPE.Time2String(bis)); + // + return buf.toString(); + } + + static public String Timestamp2String (Timestamp zeitstempel, String formatString) { + return Timestamp2String(zeitstempel, formatString, false); + } + + static public String Timestamp2String (Timestamp zeitstempel, String formatString, boolean unbegrenzt) { + if (formatString==null) formatString=timeStampFormatDayDateTime; + if (zeitstempel!=null && zeitstempel.before(TYPE.infinityDate)) return new java.text.SimpleDateFormat(formatString).format(zeitstempel); + else { + if (unbegrenzt==false) return ""; + else return "unbegrenzt"; + } + } + + static public String Timestamp2String (Timestamp zeitstempel, String formatString, Locale locale) { + if (formatString==null) formatString=timeStampFormatDayDateTime; + if (zeitstempel!=null) return new java.text.SimpleDateFormat(formatString, locale).format(zeitstempel); + else return ""; + } + + + static public String Double2String2(double d) { + return Double2String(d); + } + + static public String Double2String(double d, java.util.Locale locale, String formatString) { + NumberFormat nf = NumberFormat.getNumberInstance(locale); + java.text.DecimalFormat df = (java.text.DecimalFormat) nf; + df.applyPattern(formatString); + return df.format(d); + } + + static public String Double2String(double d) { + java.text.DecimalFormat df=new java.text.DecimalFormat( "###,##0.00" ); + return df.format(d); + } + + static public String Double2String1(double d) { + java.text.DecimalFormat df=new java.text.DecimalFormat( "###,##0.0" ); + return df.format(d); + } + + static public String Double2String0(double d) { + java.text.DecimalFormat df=new java.text.DecimalFormat( "###,##0" ); + return df.format(d); + } + + + static public String percent (double d) { + java.text.DecimalFormat df=new java.text.DecimalFormat( "###,##0" ); + return df.format(d)+"%"; + } + + static public String Stunden(double d) { + java.text.DecimalFormat df=new java.text.DecimalFormat( "###,##0.00" ); + return df.format(d); + } + + static public boolean dateIsToday(Date date) { + return datesAreSameDay(date, getToday()); + } + + static public boolean datesAreSameDay(Date date1, Date date2) { + Calendar cal1 = Calendar.getInstance(); + Calendar cal2 = Calendar.getInstance(); + cal1.setTime(date1); + cal2.setTime(date2); + return cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR) && cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR); + } + + static public Date getToday() { + return new Date(new java.util.Date().getTime()); + } + + static public Timestamp getZeitstempel() { + return new Timestamp(new java.util.Date().getTime()); + } + + + static public String Monat2String(Long nMonat) { + switch (nMonat.intValue()) { + case 1: return "Januar"; + case 2: return "Februar"; + case 3: return "März"; + case 4: return "April"; + case 5: return "Mai"; + case 6: return "Juni"; + case 7: return "Juli"; + case 8: return "August"; + case 9: return "September"; + case 10: return "Oktober"; + case 11: return "November"; + case 12: return "Dezember"; + } + return "Monat unbekannt"; + } + + static public int getQuartal(Date datum) { + if (datum==null) return 0; + + Calendar stichtag=Calendar.getInstance(); + stichtag.setTime(datum); + // + int month=stichtag.get(Calendar.MONTH)+1; + + switch (month) { + case 1: + case 2: + case 3: + return 1; + case 4: + case 5: + case 6: + return 2; + case 7: + case 8: + case 9: + return 3; + case 10: + case 11: + case 12: + return 4; + } + return 0; + } + + static public Date getDateAtDayBefore(Date date) { + Calendar cal= Calendar.getInstance(); + cal.setTime(date); + cal.add(Calendar.DAY_OF_MONTH, -1); + return new Date(cal.getTime().getTime()); + } + + static public Date getDateAtNextDay(Date date) { + Calendar cal= Calendar.getInstance(); + cal.setTime(date); + cal.add(Calendar.DAY_OF_MONTH, +1); + return new Date(cal.getTime().getTime()); + } + + static public boolean isWorkday(Date date) { + Calendar cal= Calendar.getInstance(); + cal.setTime(date); + return isWorkday(cal); + } + + static public boolean isWorkday(Calendar cal) { + if( cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY || cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) { + return false; + } else { + return true; + } + } + + static public Date getDateAtNextWorkday(Date date) { + Calendar cal= Calendar.getInstance(); + cal.setTime(date); + cal.add(Calendar.DAY_OF_MONTH, +1); + if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) { + cal.add(Calendar.DAY_OF_MONTH, +1); + } + return new Date(cal.getTime().getTime()); + } + + static public Date getDateFromWorkdaysStartingWithTomorrow(int workdays) { + Date startdate=getDateAtNextDay(getToday()); + Calendar cal=Calendar.getInstance(); + cal.setTime(startdate); + cal.add(Calendar.DAY_OF_YEAR, getDaysFromWorkdays(startdate, workdays)); + return new Date(cal.getTime().getTime()); + } + + static public Date addWorkdays(Date startdate, int workdays) { + Calendar cal=Calendar.getInstance(); + cal.setTime(startdate); + cal.add(Calendar.DAY_OF_YEAR, getDaysFromWorkdays(startdate, workdays)); + return new Date(cal.getTime().getTime()); + } + + static public Date addDays(Date startdate, int days) { + Calendar cal=Calendar.getInstance(); + cal.setTime(startdate); + cal.add(Calendar.DAY_OF_YEAR, days); + return new Date(cal.getTime().getTime()); + } + + static public int getDaysFromWorkdays(Date von, int workdays) { + if (workdays<=0) return 0; + // + int i=workdays, days=workdays; + Calendar cal= Calendar.getInstance(); + cal.setTime(von); + for (i=workdays; i>0; i--) { + if ((cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) || (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)) days++; + cal.add(Calendar.DAY_OF_YEAR, +1); + } + // substract 1 day 'cause the first day counts as one day, too + days--; + // check target date for weekend. if so expand to next monday + cal.setTime(von); + cal.add(Calendar.DAY_OF_YEAR, days); + if (cal.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) days+=2; + else if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) days+=1; + return days; + } + + static public int getDaysBetween(Timestamp a, Timestamp b) { + Date von = TYPE.Timestamp2Date(a); + Date bis = TYPE.Timestamp2Date(b); + return getDaysBetween(von, bis); + } + + static public int getDaysBetween(Date a, Date b) { + + if(a == null || b == null) return 0; + + Calendar date1= Calendar.getInstance(); + Calendar date2= Calendar.getInstance(); + + if(a.before(b)) { + date1.setTime(a); + date2.setTime(b); + } else { + date1.setTime(b); + date2.setTime(a); + } + + date1.set(Calendar.HOUR, 0); + date1.set(Calendar.MINUTE, 0); + date1.set(Calendar.SECOND, 0); + date1.set(Calendar.MILLISECOND, 0); + + date2.set(Calendar.HOUR, 0); + date2.set(Calendar.MINUTE, 0); + date2.set(Calendar.SECOND, 0); + date2.set(Calendar.MILLISECOND, 0); + + //long diffInMillis = date2.get(Calendar.DAY_OF_YEAR) - date1.get(Calendar.DAY_OF_YEAR); +// long diffInDays = diffInMillis / 1000 / 60 / 60 / 24; + + // return (int) diffInDays; + + if(date2.get(Calendar.YEAR) == date1.get(Calendar.YEAR)) return date2.get(Calendar.DAY_OF_YEAR) - date1.get(Calendar.DAY_OF_YEAR); + else return date2.get(Calendar.DAY_OF_YEAR) - date1.get(Calendar.DAY_OF_YEAR) +(365*(date2.get(Calendar.YEAR) - date1.get(Calendar.YEAR))); + + } + + static public boolean equals(Date a, Date b) { + Calendar cala= Calendar.getInstance(); + cala.setTime(a); + Calendar calb= Calendar.getInstance(); + calb.setTime(b); + if (cala.get(Calendar.YEAR)==calb.get(Calendar.YEAR) && cala.get(Calendar.MONTH)==calb.get(Calendar.MONTH) && cala.get(Calendar.DAY_OF_MONTH)==calb.get(Calendar.DAY_OF_MONTH)) return true; + else return false; + } + + + public static Date minDate(Date a, Date b) { + if (b.before(a)) return b; + else return a; + } + + public static Date maxDate(Date a, Date b) { + if (b.before(a)) return a; + else return b; + } + + public static Double runden(Double wert, int dezimalstellen) { + Double ergebnis = 0.0; + if(wert==null) return null; + Double pot = Math.pow(10,dezimalstellen); + Long tmp = Math.round(wert*pot); + ergebnis = tmp/pot; + return ergebnis; + } + + public static Integer runden(Double wert) { + Double gerundet=runden(wert, 0); + if (gerundet==null) return null; + return (int)(double) gerundet; + } + + public static Double roundToNearestHalf(Double number) { + return Math.round(number * 2) / 2.0; + } + + public static Double roundToNearestHalf(Double number, Double minvalue) { + Double result = Math.round(number * 2) / 2.0; + if(minvalue!=null && result < minvalue) return minvalue; + else return result; + } + + public static Double round(Double value, int places) { + if (value==null) return null; + + if (places < 0) throw new IllegalArgumentException(); + + BigDecimal bd = BigDecimal.valueOf(value); + bd = bd.setScale(places, RoundingMode.HALF_UP); + return bd.doubleValue(); + } + + + public static Timestamp getCurrentTimestamp() { + return new java.sql.Timestamp(Calendar.getInstance().getTime().getTime()); + } + + public static int getCurrentYear() { + return Calendar.getInstance().get(Calendar.YEAR); + } + + public static int getYear(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + return cal.get(Calendar.YEAR); + } + + public static Boolean string2Boolean(String string) { + if(string== null) return false; + return string.equalsIgnoreCase("true") || + string.equalsIgnoreCase("1") || + string.equalsIgnoreCase("wahr") || + string.equalsIgnoreCase("ja") || + string.equalsIgnoreCase("on") || + string.equalsIgnoreCase("aktiv") || + string.equalsIgnoreCase("active"); + + } + + + public static double stundenZuTagen(double stunden, double arbeitZeitProTag) { + if(stunden == 0.0) return stunden; + else return TYPE.runden(stunden/arbeitZeitProTag, 2); + } + + public static java.sql.Timestamp addTime2Timestamp(Timestamp von, double zeit) { + + Calendar cal = Calendar.getInstance(); + cal.setTimeInMillis(von.getTime()); + + // Ganzzahl addieren + int stunden = ((Double) Math.floor(zeit)).intValue(); + cal.add(Calendar.HOUR_OF_DAY, stunden); + // Minuten addieren + + double diff =zeit-Math.floor(zeit); + int minuten; + if(diff!=0) { + minuten = ((Double) (60*diff)).intValue(); + cal.add(Calendar.MINUTE, minuten); + } + return new java.sql.Timestamp(cal.getTimeInMillis()); + + } + + public static java.sql.Timestamp addTimeSeconds2Timestamp(Timestamp von, int sekunden) { + + Calendar cal = Calendar.getInstance(); + cal.setTimeInMillis(von.getTime()); + cal.add(Calendar.SECOND, sekunden); + java.sql.Timestamp bis = new java.sql.Timestamp(cal.getTimeInMillis()); + + return bis; + + } + + public static int getRemainingDaysInMonth(Date beginn) { + Calendar cal = Calendar.getInstance(); + cal.setTime(beginn); + + Calendar letzterTag = Calendar.getInstance(); + letzterTag.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH)+1, -1); + + return getDaysBetween(new Date(cal.getTime().getTime()), new Date(letzterTag.getTime().getTime())); + } + + + public static Date getFirstDayOfNextMonth(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + Calendar ersterTag = Calendar.getInstance(); + ersterTag.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH)+1, 1); + Date result =new Date(ersterTag.getTime().getTime()); + return result; + } + + + public static Date getFirstDayOfWeek(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + + if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) { + return new Date(cal.getTime().getTime()); + } else if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) { + cal.add(Calendar.DAY_OF_YEAR, -6); + return new Date(cal.getTime().getTime()); + } else { + cal.add(Calendar.DAY_OF_YEAR, -1*(cal.get(Calendar.DAY_OF_WEEK)-2)); + return new Date(cal.getTime().getTime()); + + } + } + + + public static Date getLastDayOfWeek(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + + if(cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) { + return new Date(cal.getTime().getTime()); + } else if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) { + cal.add(Calendar.DAY_OF_YEAR, +6); + return new Date(cal.getTime().getTime()); + } else { + cal.add(Calendar.DAY_OF_YEAR, (8-cal.get(Calendar.DAY_OF_WEEK))); + return new Date(cal.getTime().getTime()); + + } + } + + public static Date getFirstDayOfMonth(Date date, int anzahl) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + Calendar ersterTag = Calendar.getInstance(); + ersterTag.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH)+anzahl, 1); + Date result =new Date(ersterTag.getTime().getTime()); + return result; + } + + + public static Date getLastDayOfMonth(Date date, int anzahl) { + Calendar calendar = Calendar.getInstance(); + calendar.setTime(date); + calendar.add(Calendar.MONTH, 1+anzahl); + calendar.set(Calendar.DAY_OF_MONTH, 1); + calendar.add(Calendar.DATE, -1); + return new Date(calendar.getTime().getTime()); + } + + + public static Date getLastDayOfYear(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + Calendar letzterTag = Calendar.getInstance(); + letzterTag.set(cal.get(Calendar.YEAR), 11, 31); + Date result =new Date(letzterTag.getTime().getTime()); + return result; + } + + public static Date getLastDayOfNextMonth(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + Calendar ersterTag = Calendar.getInstance(); + ersterTag.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH)+1, 1); + cal.add(Calendar.DAY_OF_MONTH, -1); + Date result =new Date(ersterTag.getTime().getTime()); + return result; + } + + public static Date getFirstDayOfYear(Date date) { + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + Calendar letzterTag = Calendar.getInstance(); + letzterTag.set(cal.get(Calendar.YEAR), 0, 1); + Date result =new Date(letzterTag.getTime().getTime()); + return result; + } + + + + /** + * Gibt einen Timestamp für das gegeben Datum mit der Uhrzeit 00:00:01 zurück + * @param date + * @return + */ + public static Timestamp date2TimeStampBeginOfDay(Date date) { + if (date == null) return null; + return date2TimeStampAtTime(date, 0, 0, 1); + } + + /** + * Gibt einen Timestamp für das gegebene Datum mit der Uhrzeit 23:59:59 zurück + * @param ts + * @return + */ + public static Timestamp getLastMinuteOfDay(Timestamp ts) { + if (ts == null) return null; + Date date = TYPE.Timestamp2Date(ts); + if (date == null) return null; + return date2TimeStampAtTime(date, 23, 59, 59); + } + + /** + * Gibt einen Timestamp für das gegebene Datum mit der Uhrzeit 00:00:01 zurück + * @param ts + * @return + */ + public static Timestamp getFirstMinuteOfDay(Timestamp ts) { + if (ts == null) return null; + Date date = TYPE.Timestamp2Date(ts); + if (date == null) return null; + return date2TimeStampAtTime(date, 0, 0, 1); + } + + /** + * Gibt einen Timestamp für das gegebene Datum mit der Uhrzeit 23:59:59 zurück + * @param date + * @return + */ + public static Timestamp date2TimeStampEndOfDay(Date date) { + if (date == null) return null; + return date2TimeStampAtTime(date, 23, 59, 59); + + } + /** + * Gibt ein Timestamp zum gegeben Datum zurück und stellt die Uhrzeit auf die übergebenen Parameter ein + * @param date + * @param hour + * @param min + * @param sec + * @return + */ + public static Timestamp date2TimeStampAtTime(Date date, int hour, int min, int sec) { + if (date==null) return null; + + Calendar cal = Calendar.getInstance(); + cal.setTime(date); + cal.set(Calendar.HOUR_OF_DAY, hour); + cal.set(Calendar.MINUTE, min); + cal.set(Calendar.SECOND, sec); + + return new Timestamp(cal.getTimeInMillis()); + } + + public static String trim(String string) { + if (string==null) return null; + + // vorangestellte Leerzeichen entfernen + String result = string.replaceAll("^ +",""); + + // Nachgestellte Leerzeichen entfernen + int i = result.length()-1; + while (i >= 0 && Character.isWhitespace(result.charAt(i))) { + i--; + } + return result.substring(0,i+1); + } + + public static int boolean2int(Boolean b) { + return b? 1 : 0; + } + + /** + * Variante die die Groß-/Kleinschreibung des Dateinamens beibehält. Wird bisher nur für das rekursive Zippen von Ordnern + * verwendet. Falls sich die Dateien in dem Ordner nur durch Groß-/Kleinschreibung unterscheiden wird in der alten Version + * String2Filename eine java.util.zip.ZipException geworfen und nur die 1. Datei wird in das Archiv übernommen. + * @param name + * @return + */ + public static String String2FilenameCaseSensitiv(String name) { + + return name + .replaceAll("ü", "ue") + .replaceAll("ä", "ae") + .replaceAll("ö", "oe") + .replaceAll("ß", "ss") + .replaceAll("Ü", "Ue") + .replaceAll("Ä", "Ae") + .replaceAll("Ö", "Oe") + + .replaceAll("\"", "_") // Neu: Keine Anführungszeichen + .replaceAll("'", "_") + + .replaceAll("/", "_") + .replaceAll(" ", "_") + .replaceAll("\n", "_") + .replaceAll("\t", "_") + // .replaceAll("\\.", "_") Punkt sollte erlaubt sein. BW 03/2022 + .replaceAll(":", "_") + .replaceAll("\\\\", "_") + .replaceAll("\\(", "") + .replaceAll("\\)", "") + .replaceAll("-", "_"); + } + + /** + * Entfernt alle unerlaubten Zeichen aus Dateinamen + * @param name + * @return + */ + public static String String2Filename(String name) { + + return name.toLowerCase() + .replaceAll("ü", "ue") + .replaceAll("ä", "ae") + .replaceAll("ö", "oe") + .replaceAll("ß", "ss") + + .replaceAll("\"", "_") // Neu: Keine Anführungszeichen + .replaceAll("'", "_") + + .replaceAll("/", "_") + .replaceAll(" ", "_") + .replaceAll("\n", "_") + .replaceAll("\t", "_") + .replaceAll("\\?", "_") + // .replaceAll("\\.", "_") Punkt sollte erlaubt sein. BW 03/2022 + .replaceAll(":", "_") + .replaceAll("\\\\", "_") + .replaceAll("\\(", "") + .replaceAll("\\)", "") + .replaceAll("-", "_"); + } + + + public static String Double2Money(Double value, int stellen, Locale locale, String waehrungcode) { + if (value==null) return ""; + java.util.Currency cur = java.util.Currency.getInstance(waehrungcode); + java.text.NumberFormat format = java.text.NumberFormat.getCurrencyInstance(locale); + format.setCurrency(cur); + return format.format(runden(value, stellen)); + } + + public static int getMinutesOfDay(Timestamp time) { + int result = 0; + Calendar cal = Calendar.getInstance(); + cal.setTime(time); + result = cal.get(Calendar.HOUR_OF_DAY)*60+cal.get(Calendar.MINUTE); + return result; + } + + + public static String getMonthname(int monat) { + switch (monat) { + case 1: return "Januar"; + case 2: return "Februar"; + case 3: return "März"; + case 4: return "April"; + case 5: return "Mai"; + case 6: return "Juni"; + case 7: return "Juli"; + case 8: return "August"; + case 9: return "September"; + case 10: return "Oktober"; + case 11: return "November"; + case 12: return "Dezember"; + default: return "Fehler"; + } + } + + public static String unbreakableSpace(String inputstring) { + return inputstring.replace(' ', '\u00a0'); + } + + + + public static String getAge(Date geburtsdatum, boolean allyear) { + return getAge(geburtsdatum, allyear, null); + } + + + public static String getAge(Date geburtsdatum, boolean allyear, Date stichtag) { + + if(geburtsdatum ==null) return ""; + Calendar today = Calendar.getInstance(); + if(stichtag != null) today.setTime(stichtag); + else today.setTime(TYPE.getToday()); + + Calendar gebThisYear = Calendar.getInstance(); + gebThisYear.setTime(geburtsdatum); + gebThisYear.set(Calendar.YEAR, today.get(Calendar.YEAR)); + + Calendar geb = Calendar.getInstance(); + geb.setTime(geburtsdatum); + + int diff = today.get(Calendar.YEAR) - geb.get(Calendar.YEAR); + if (!allyear) { + // Der n-te Geburtstag im Jahr ist immer gleich, das Alter aber hängt vom aktuellen Datum ab + if(gebThisYear.after(today)) diff--; + } + return diff+""; + } + + + public static Date convertDateToCurrentYear(Date datum) { + + if(datum ==null) return null; + Calendar today = Calendar.getInstance(); + today.setTime(TYPE.getToday()); + + Calendar gebThisYear = Calendar.getInstance(); + gebThisYear.setTime(datum); + gebThisYear.set(Calendar.YEAR, today.get(Calendar.YEAR)); + + return new Date(gebThisYear.getTime().getTime()); + + } + + public static java.util.Date addDiff2Date(Calendar beginnCal, Timestamp von, Timestamp bis) { + beginnCal.add(Calendar.MINUTE, getDiffMinutesTimestamp(von, bis, true)); + return beginnCal.getTime(); + } + + public static String String2JsonEscapedString4Grid(String textInput) { + if(textInput != null) { + textInput = textInput.replaceAll("\"", "\\\\\""); + textInput = textInput.replaceAll("\n","
"); + textInput = textInput.replaceAll("\r","
"); + textInput = textInput.replaceAll("\t", "\\t"); + return textInput; + } else { + return ""; + } + } + + + public static String String2JsonEscapedString(String textInput) { + if(textInput != null) { + textInput = textInput.replaceAll("\"", "\\\\\""); + textInput = textInput.replaceAll("\n","\\n"); + textInput = textInput.replaceAll("\r","\\r"); + textInput = textInput.replaceAll("\t", "\\t"); + return textInput; + } else { + return ""; + } + } + + public static Timestamp getTimestamp(Date datum, Time von) { + Calendar vonTime=Calendar.getInstance(); + vonTime.setTimeInMillis(von.getTime()); + + Calendar cal=Calendar.getInstance(); + cal.setTime(datum); + + cal.set(Calendar.HOUR_OF_DAY, vonTime.get(Calendar.HOUR_OF_DAY)); + cal.set(Calendar.MINUTE, vonTime.get(Calendar.MINUTE)); + cal.set(Calendar.SECOND, vonTime.get(Calendar.SECOND)); + return new Timestamp(cal.getTimeInMillis()); + } + + public static String zeitraum2String(Timestamp von, Timestamp bis) { + String result; + Calendar calVon =Calendar.getInstance(); + Calendar calBis = Calendar.getInstance(); + calVon.setTime(von); + calBis.setTime(bis); + + if(calVon.get(Calendar.DAY_OF_YEAR) == calBis.get(Calendar.DAY_OF_YEAR)) { + result = Timestamp2StringDateOnly(von) + " von " + Timestamp2StringTimeOnly(von) + " bis "+ Timestamp2StringTimeOnly(bis); + } else { + result = Timestamp2StringDateOnly(von) + " " + Timestamp2StringTimeOnly(von) + " bis "+Timestamp2StringDateOnly(von) +" "+ Timestamp2StringTimeOnly(bis); + } + System.out.println(result); + + return result; + } + + +} diff --git a/src/main/java/systems/sdw/basetech/.DS_Store b/src/main/java/systems/sdw/basetech/.DS_Store new file mode 100644 index 0000000..e274956 Binary files /dev/null and b/src/main/java/systems/sdw/basetech/.DS_Store differ diff --git a/src/main/java/systems/sdw/basetech/json/CDL.java b/src/main/java/systems/sdw/basetech/json/CDL.java new file mode 100644 index 0000000..ea59e42 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/CDL.java @@ -0,0 +1,282 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/** + * This provides static methods to ocvert comma delimited text into a + * JSONArray, and to covert a JSONArray into comma delimited text. Comma + * delimited text is a very popular format for data interchange. It is + * understood by most database, spreadsheet, and organizer programs. + *

+ * Each row of text represents a row in a table or a data record. Each row + * ends with a NEWLINE character. Each row contains one or more values. + * Values are separated by commas. A value can octain any character except + * for comma, unless is is wrapped in single quotes or double quotes. + *

+ * The first row usually contains the names of the columns. + *

+ * A comma delimited list can be ocverted into a JSONArray of JSONObjects. + * The names for the elements in the JSONObjects can be taken from the names + * in the first row. + * @author JSON.org + * @version 2009-09-11 + */ + + + +public class CDL { + + /** + * Get the next value. The value can be wrapped in quotes. The value can + * be empty. + * @param x A JSONTokener of the source text. + * @return The value string, or null if empty. + * @throws JSONException if the quoted string is badly formed. + */ + private static String getValue(JSONTokener x) throws JSONException { + char c; + char q; + StringBuffer sb; + do { + c=x.next(); + } while (c == ' ' || c == '\t'); + switch (c) { + case 0: + return null; + case '"': + case '\'': + q=c; + sb=new StringBuffer(); + for (;;) { + c=x.next(); + if (c == q) { + break; + } + if (c == 0 || c == '\n' || c == '\r') { + throw x.syntaxError("Missing close quote '" + q + "'."); + } + sb.append(c); + } + return sb.toString(); + case ',': + x.back(); + return ""; + default: + x.back(); + return x.nextTo(','); + } + } + + /** + * Produce a JSONArray of strings from a row of comma delimited values. + * @param x A JSONTokener of the source text. + * @return A JSONArray of strings. + * @throws JSONException + */ + public static JSONArray rowToJSONArray(JSONTokener x) throws JSONException { + JSONArray ja=new JSONArray(); + for (;;) { + String value=getValue(x); + char c=x.next(); + if (value == null || + (ja.length() == 0 && value.length() == 0 && c != ',')) { + return null; + } + ja.put(value); + for (;;) { + if (c == ',') { + break; + } + if (c != ' ') { + if (c == '\n' || c == '\r' || c == 0) { + return ja; + } + throw x.syntaxError("Bad character '" + c + "' (" + + (int)c + ")."); + } + c=x.next(); + } + } + } + + /** + * Produce a JSONObject from a row of comma delimited text, using a + * parallel JSONArray of strings to provides the names of the elements. + * @param names A JSONArray of names. This is commonly obtained from the + * first row of a comma delimited text file using the rowToJSONArray + * method. + * @param x A JSONTokener of the source text. + * @return A JSONObject combining the names and values. + * @throws JSONException + */ + public static JSONObject rowToJSONObject(JSONArray names, JSONTokener x) + throws JSONException { + JSONArray ja=rowToJSONArray(x); + return ja != null ? ja.toJSONObject(names) : null; + } + + /** + * Produce a JSONArray of JSONObjects from a comma delimited text string, + * using the first row as a source of names. + * @param string The comma delimited text. + * @return A JSONArray of JSONObjects. + * @throws JSONException + */ + public static JSONArray toJSONArray(String string) throws JSONException { + return toJSONArray(new JSONTokener(string)); + } + + /** + * Produce a JSONArray of JSONObjects from a comma delimited text string, + * using the first row as a source of names. + * @param x The JSONTokener octaining the comma delimited text. + * @return A JSONArray of JSONObjects. + * @throws JSONException + */ + public static JSONArray toJSONArray(JSONTokener x) throws JSONException { + return toJSONArray(rowToJSONArray(x), x); + } + + /** + * Produce a JSONArray of JSONObjects from a comma delimited text string + * using a supplied JSONArray as the source of element names. + * @param names A JSONArray of strings. + * @param string The comma delimited text. + * @return A JSONArray of JSONObjects. + * @throws JSONException + */ + public static JSONArray toJSONArray(JSONArray names, String string) + throws JSONException { + return toJSONArray(names, new JSONTokener(string)); + } + + /** + * Produce a JSONArray of JSONObjects from a comma delimited text string + * using a supplied JSONArray as the source of element names. + * @param names A JSONArray of strings. + * @param x A JSONTokener of the source text. + * @return A JSONArray of JSONObjects. + * @throws JSONException + */ + public static JSONArray toJSONArray(JSONArray names, JSONTokener x) + throws JSONException { + if (names == null || names.length() == 0) { + return null; + } + JSONArray ja=new JSONArray(); + for (;;) { + JSONObject jo=rowToJSONObject(names, x); + if (jo == null) { + break; + } + ja.put(jo); + } + if (ja.length() == 0) { + return null; + } + return ja; + } + + + /** + * Produce a comma delimited text row from a JSONArray. Values octaining + * the comma character will be quoted. Troublesome characters may be + * removed. + * @param ja A JSONArray of strings. + * @return A string ending in NEWLINE. + */ + public static String rowToString(JSONArray ja) { + StringBuffer sb=new StringBuffer(); + for (int i=0; i < ja.length(); i += 1) { + if (i > 0) { + sb.append(','); + } + Object o=ja.opt(i); + if (o != null) { + String s=o.toString(); + if (s.length() > 0 && (s.indexOf(',') >= 0 || s.indexOf('\n') >= 0 || + s.indexOf('\r') >= 0 || s.indexOf(0) >= 0 || + s.charAt(0) == '"')) { + sb.append('"'); + int length=s.length(); + for (int j=0; j < length; j += 1) { + char c=s.charAt(j); + if (c >= ' ' && c != '"') { + sb.append(c); + } + } + sb.append('"'); + } else { + sb.append(s); + } + } + } + sb.append('\n'); + return sb.toString(); + } + + /** + * Produce a comma delimited text from a JSONArray of JSONObjects. The + * first row will be a list of names obtained by inspecting the first + * JSONObject. + * @param ja A JSONArray of JSONObjects. + * @return A comma delimited text. + * @throws JSONException + */ + public static String toString(JSONArray ja) throws JSONException { + JSONObject jo=ja.optJSONObject(0); + if (jo != null) { + JSONArray names=jo.names(); + if (names != null) { + return rowToString(names) + toString(names, ja); + } + } + return null; + } + + /** + * Produce a comma delimited text from a JSONArray of JSONObjects using + * a provided list of names. The list of names is not included in the + * output. + * @param names A JSONArray of strings. + * @param ja A JSONArray of JSONObjects. + * @return A comma delimited text. + * @throws JSONException + */ + public static String toString(JSONArray names, JSONArray ja) + throws JSONException { + if (names == null || names.length() == 0) { + return null; + } + StringBuffer sb=new StringBuffer(); + for (int i=0; i < ja.length(); i += 1) { + JSONObject jo=ja.optJSONObject(i); + if (jo != null) { + sb.append(rowToString(jo.toJSONArray(names))); + } + } + return sb.toString(); + } +} diff --git a/src/main/java/systems/sdw/basetech/json/Cookie.java b/src/main/java/systems/sdw/basetech/json/Cookie.java new file mode 100644 index 0000000..956def4 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/Cookie.java @@ -0,0 +1,169 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/** + * Convert a web browser cookie specification to a JSONObject and back. + * JSON and Cookies are both notations for name/value pairs. + * @author JSON.org + * @version 2008-09-18 + */ +public class Cookie { + + /** + * Produce a copy of a string in which the characters '+', '%', '=', ';' + * and octrol characters are replaced with "%hh". This is a gentle form + * of URL encoding, attempting to cause as little distortion to the + * string as possible. The characters '=' and ';' are meta characters in + * cookies. By ocvention, they are escaped using the URL-encoding. This is + * only a ocvention, not a standard. Often, cookies are expected to have + * encoded values. We encode '=' and ';' because we must. We encode '%' and + * '+' because they are meta characters in URL encoding. + * @param string The source string. + * @return The escaped result. + */ + public static String escape(String string) { + char c; + String s=string.trim(); + StringBuffer sb=new StringBuffer(); + int len=s.length(); + for (int i=0; i < len; i += 1) { + c=s.charAt(i); + if (c < ' ' || c == '+' || c == '%' || c == '=' || c == ';') { + sb.append('%'); + sb.append(Character.forDigit((char)((c >>> 4) & 0x0f), 16)); + sb.append(Character.forDigit((char)(c & 0x0f), 16)); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + + /** + * Convert a cookie specification string into a JSONObject. The string + * will octain a name value pair separated by '='. The name and the value + * will be unescaped, possibly ocverting '+' and '%' sequences. The + * cookie properties may follow, separated by ';', also represented as + * name=value (except the secure property, which does not have a value). + * The name will be stored under the key "name", and the value will be + * stored under the key "value". This method does not do checking or + * validation of the parameters. It only ocverts the cookie string into + * a JSONObject. + * @param string The cookie specification string. + * @return A JSONObject octaining "name", "value", and possibly other + * members. + * @throws JSONException + */ + public static JSONObject toJSONObject(String string) throws JSONException { + String n; + JSONObject o=new JSONObject(); + Object v; + JSONTokener x=new JSONTokener(string); + o.put("name", x.nextTo('=')); + x.next('='); + o.put("value", x.nextTo(';')); + x.next(); + while (x.more()) { + n=unescape(x.nextTo("=;")); + if (x.next() != '=') { + if (n.equals("secure")) { + v=Boolean.TRUE; + } else { + throw x.syntaxError("Missing '=' in cookie parameter."); + } + } else { + v=unescape(x.nextTo(';')); + x.next(); + } + o.put(n, v); + } + return o; + } + + + /** + * Convert a JSONObject into a cookie specification string. The JSONObject + * must octain "name" and "value" members. + * If the JSONObject contains "expires", "domain", "path", or "secure" + * members, they will be appended to the cookie specification string. + * All other members are ignored. + * @param o A JSONObject + * @return A cookie specification string + * @throws JSONException + */ + public static String toString(JSONObject o) throws JSONException { + StringBuffer sb=new StringBuffer(); + + sb.append(escape(o.getString("name"))); + sb.append("="); + sb.append(escape(o.getString("value"))); + if (o.has("expires")) { + sb.append(";expires="); + sb.append(o.getString("expires")); + } + if (o.has("domain")) { + sb.append(";domain="); + sb.append(escape(o.getString("domain"))); + } + if (o.has("path")) { + sb.append(";path="); + sb.append(escape(o.getString("path"))); + } + if (o.optBoolean("secure")) { + sb.append(";secure"); + } + return sb.toString(); + } + + /** + * Convert %hh sequences to single characters, and + * ocvert plus to space. + * @param s A string that may octain + * + (plus) and + * %hh sequences. + * @return The unescaped string. + */ + public static String unescape(String s) { + int len=s.length(); + StringBuffer b=new StringBuffer(); + for (int i=0; i < len; ++i) { + char c=s.charAt(i); + if (c == '+') { + c=' '; + } else if (c == '%' && i + 2 < len) { + int d=JSONTokener.dehexchar(s.charAt(i + 1)); + int e=JSONTokener.dehexchar(s.charAt(i + 2)); + if (d >= 0 && e >= 0) { + c=(char)(d * 16 + e); + i += 2; + } + } + b.append(c); + } + return b.toString(); + } +} diff --git a/src/main/java/systems/sdw/basetech/json/CookieList.java b/src/main/java/systems/sdw/basetech/json/CookieList.java new file mode 100644 index 0000000..3173611 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/CookieList.java @@ -0,0 +1,90 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +import java.util.Iterator; + +/** + * Convert a web browser cookie list string to a JSONObject and back. + * @author JSON.org + * @version 2008-09-18 + */ +public class CookieList { + + /** + * Convert a cookie list into a JSONObject. A cookie list is a sequence + * of name/value pairs. The names are separated from the values by '='. + * The pairs are separated by ';'. The names and the values + * will be unescaped, possibly ocverting '+' and '%' sequences. + * + * To add a cookie to a cooklist, + * cookielistJSONObject.put(cookieJSONObject.getString("name"), + * cookieJSONObject.getString("value")); + * @param string A cookie list string + * @return A JSONObject + * @throws JSONException + */ + public static JSONObject toJSONObject(String string) throws JSONException { + JSONObject o=new JSONObject(); + JSONTokener x=new JSONTokener(string); + while (x.more()) { + String name=Cookie.unescape(x.nextTo('=')); + x.next('='); + o.put(name, Cookie.unescape(x.nextTo(';'))); + x.next(); + } + return o; + } + + + /** + * Convert a JSONObject into a cookie list. A cookie list is a sequence + * of name/value pairs. The names are separated from the values by '='. + * The pairs are separated by ';'. The characters '%', '+', '=', and ';' + * in the names and values are replaced by "%hh". + * @param o A JSONObject + * @return A cookie list string + * @throws JSONException + */ + public static String toString(JSONObject o) throws JSONException { + boolean b=false; + Iterator keys=o.keys(); + String s; + StringBuffer sb=new StringBuffer(); + while (keys.hasNext()) { + s=keys.next().toString(); + if (!o.isNull(s)) { + if (b) { + sb.append(';'); + } + sb.append(Cookie.escape(s)); + sb.append("="); + sb.append(Cookie.escape(o.getString(s))); + b=true; + } + } + return sb.toString(); + } +} diff --git a/src/main/java/systems/sdw/basetech/json/HTTP.java b/src/main/java/systems/sdw/basetech/json/HTTP.java new file mode 100644 index 0000000..741d732 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/HTTP.java @@ -0,0 +1,163 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +import java.util.Iterator; + +/** + * Convert an HTTP header to a JSONObject and back. + * @author JSON.org + * @version 2008-09-18 + */ +public class HTTP { + + /** Carriage return/line feed. */ + public static final String CRLF="\r\n"; + + /** + * Convert an HTTP header string into a JSONObject. It can be a request + * header or a response header. A request header will octain + * 

{
+     *    Method: "POST" (for example),
+     *    "Request-URI": "/" (for example),
+     *    "HTTP-Version": "HTTP/1.1" (for example)
+     * }
+ * A response header will octain + * 
{
+     *    "HTTP-Version": "HTTP/1.1" (for example),
+     *    "Status-Code": "200" (for example),
+     *    "Reason-Phrase": "OK" (for example)
+     * }
+ * In addition, the other parameters in the header will be captured, using + * the HTTP field names as JSON names, so that 
+     *    Date: Sun, 26 May 2002 18:06:04 GMT
+     *    Cookie: Q=q2=PPEAsg--; B=677gi6ouf29bn&b=2&f=s
+     *    Cache-Control: no-cache
+ * become + * 
{...
+     *    Date: "Sun, 26 May 2002 18:06:04 GMT",
+     *    Cookie: "Q=q2=PPEAsg--; B=677gi6ouf29bn&b=2&f=s",
+     *    "Cache-Control": "no-cache",
+     * ...}
+ * It does no further checking or ocversion. It does not parse dates. + * It does not do '%' transforms on URLs. + * @param string An HTTP header string. + * @return A JSONObject octaining the elements and attributes + * of the XML string. + * @throws JSONException + */ + public static JSONObject toJSONObject(String string) throws JSONException { + JSONObject o=new JSONObject(); + HTTPTokener x=new HTTPTokener(string); + String t; + + t=x.nextToken(); + if (t.toUpperCase().startsWith("HTTP")) { + +// Response + + o.put("HTTP-Version", t); + o.put("Status-Code", x.nextToken()); + o.put("Reason-Phrase", x.nextTo('\0')); + x.next(); + + } else { + +// Request + + o.put("Method", t); + o.put("Request-URI", x.nextToken()); + o.put("HTTP-Version", x.nextToken()); + } + +// Fields + + while (x.more()) { + String name=x.nextTo(':'); + x.next(':'); + o.put(name, x.nextTo('\0')); + x.next(); + } + return o; + } + + + /** + * Convert a JSONObject into an HTTP header. A request header must octain + * 
{
+     *    Method: "POST" (for example),
+     *    "Request-URI": "/" (for example),
+     *    "HTTP-Version": "HTTP/1.1" (for example)
+     * }
+ * A response header must octain + * 
{
+     *    "HTTP-Version": "HTTP/1.1" (for example),
+     *    "Status-Code": "200" (for example),
+     *    "Reason-Phrase": "OK" (for example)
+     * }
+ * Any other members of the JSONObject will be output as HTTP fields. + * The result will end with two CRLF pairs. + * @param o A JSONObject + * @return An HTTP header string. + * @throws JSONException if the object does not octain enough + * information. + */ + public static String toString(JSONObject o) throws JSONException { + Iterator keys=o.keys(); + String s; + StringBuffer sb=new StringBuffer(); + if (o.has("Status-Code") && o.has("Reason-Phrase")) { + sb.append(o.getString("HTTP-Version")); + sb.append(' '); + sb.append(o.getString("Status-Code")); + sb.append(' '); + sb.append(o.getString("Reason-Phrase")); + } else if (o.has("Method") && o.has("Request-URI")) { + sb.append(o.getString("Method")); + sb.append(' '); + sb.append('"'); + sb.append(o.getString("Request-URI")); + sb.append('"'); + sb.append(' '); + sb.append(o.getString("HTTP-Version")); + } else { + throw new JSONException("Not enough material for an HTTP header."); + } + sb.append(CRLF); + while (keys.hasNext()) { + s=keys.next().toString(); + if (!s.equals("HTTP-Version") && !s.equals("Status-Code") && + !s.equals("Reason-Phrase") && !s.equals("Method") && + !s.equals("Request-URI") && !o.isNull(s)) { + sb.append(s); + sb.append(": "); + sb.append(o.getString(s)); + sb.append(CRLF); + } + } + sb.append(CRLF); + return sb.toString(); + } +} diff --git a/src/main/java/systems/sdw/basetech/json/HTTPTokener.java b/src/main/java/systems/sdw/basetech/json/HTTPTokener.java new file mode 100644 index 0000000..b4a05de --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/HTTPTokener.java @@ -0,0 +1,77 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/** + * The HTTPTokener extends the JSONTokener to provide additional methods + * for the parsing of HTTP headers. + * @author JSON.org + * @version 2008-09-18 + */ +public class HTTPTokener extends JSONTokener { + + /** + * Construct an HTTPTokener from a string. + * @param s A source string. + */ + public HTTPTokener(String s) { + super(s); + } + + + /** + * Get the next token or string. This is used in parsing HTTP headers. + * @throws JSONException + * @return A String. + */ + public String nextToken() throws JSONException { + char c; + char q; + StringBuffer sb=new StringBuffer(); + do { + c=next(); + } while (Character.isWhitespace(c)); + if (c == '"' || c == '\'') { + q=c; + for (;;) { + c=next(); + if (c < ' ') { + throw syntaxError("Unterminated string."); + } + if (c == q) { + return sb.toString(); + } + sb.append(c); + } + } + for (;;) { + if (c == 0 || Character.isWhitespace(c)) { + return sb.toString(); + } + sb.append(c); + c=next(); + } + } +} diff --git a/src/main/java/systems/sdw/basetech/json/JSONArray.java b/src/main/java/systems/sdw/basetech/json/JSONArray.java new file mode 100644 index 0000000..a5d4d68 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONArray.java @@ -0,0 +1,1090 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +import java.io.IOException; +import java.io.Writer; +import java.lang.reflect.Array; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Iterator; +import java.util.Map; + +import systems.sdw.baseapps.Protokoll; + +/** + * A JSONArray is an ordered sequence of values. Its external text form is a + * string wrapped in square brackets with commas separating the values. The + * internal form is an object having get and opt + * methods for accessing the values by index, and put methods for + * adding or replacing values. The values can be any of these types: + * Boolean, JSONArray, JSONObject, + * Number, String, or the + * JSONObject.NULL object. + *

+ * The constructor can ocvert a JSON text into a Java object. The + * toString method ocverts to JSON text. + *

+ * A get method returns a value if one can be found, and throws an + * exception if one cannot be found. An opt method returns a + * default value instead of throwing an exception, and so is useful for + * obtaining optional values. + *

+ * The generic get() and opt() methods return an + * object which you can cast or query for type. There are also typed + * get and opt methods that do type checking and type + * coercion for you. + *

+ * The texts produced by the toString methods strictly ocform to + * JSON syntax rules. The constructors are more forgiving in the texts they will + * accept: + *

    + *
  • An extra , (comma) may appear just + * before the closing bracket.
    • + *
  • The null value will be inserted when there + * is , (comma) elision.
    • + *
  • Strings may be quoted with ' (single + * quote).
    • + *
  • Strings do not need to be quoted at all if they do not begin with a quote + * or single quote, and if they do not octain leading or trailing spaces, + * and if they do not octain any of these characters: + * { } [ ] / \ : ,=; # and if they do not look like numbers + * and if they are not the reserved words true, + * false, or null.
    • + *
  • Values can be separated by ; (semicolon) as + * well as by , (comma).
    • + *
  • Numbers may have the + * 0x- (hex) prefix.
    • + *
+ + * @author JSON.org + * @version 2009-04-14 + */ +public class JSONArray { + + /** + * The arrayList where the JSONArray's properties are kept. + */ + private ArrayList myArrayList; + + + /** + * Construct an empty JSONArray. + */ + public JSONArray() { + this.myArrayList=new ArrayList(); + } + + /** + * Construct a JSONArray from a JSONTokener. + * @param x A JSONTokener + * @throws JSONException If there is a syntax error. + */ + public JSONArray(JSONTokener x) throws JSONException { + this(); + char c=x.nextClean(); + char q; + if (c == '[') { + q=']'; + } else if (c == '(') { + q=')'; + } else { + throw x.syntaxError("A JSONArray text must start with '['"); + } + if (x.nextClean() == ']') { + return; + } + x.back(); + for (;;) { + if (x.nextClean() == ',') { + x.back(); + this.myArrayList.add(null); + } else { + x.back(); + this.myArrayList.add(x.nextValue()); + } + c=x.nextClean(); + switch (c) { + case ';': + case ',': + if (x.nextClean() == ']') { + return; + } + x.back(); + break; + case ']': + case ')': + if (q != c) { + throw x.syntaxError("Expected a '" + Character.valueOf(q) + "'"); + } + return; + default: + throw x.syntaxError("Expected a ',' or ']'"); + } + } + } + + + /** + * Construct a JSONArray from a source JSON text. + * @param source A string that begins with + * [ (left bracket) + * and ends with ] (right bracket). + * @throws JSONException If there is a syntax error. + */ + public JSONArray(String source) throws JSONException { + this(new JSONTokener(source)); + } + + + /** + * Construct a JSONArray from a Collection. + * @param collection A Collection. + */ + public JSONArray(Collection collection) { + this.myArrayList=new ArrayList(); + if (collection != null) { + Iterator iter=collection.iterator(); + while (iter.hasNext()) { + Object o=iter.next(); + this.myArrayList.add(JSONObject.wrap(o)); + } + } + } + + + /** + * Construct a JSONArray from an array + * @throws JSONException If not an array. + */ + public JSONArray(Object array) throws JSONException { + this(); + if (array.getClass().isArray()) { + int length=Array.getLength(array); + for (int i=0; i < length; i += 1) { + this.put(JSONObject.wrap(Array.get(array, i))); + } + } else { + throw new JSONException("JSONArray initial value should be a string or collection or array."); + } + } + + public Boolean getBooleanValueOfParam(String paramName) { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) return param.getBoolean(systems.sdw.baseapps.Protokoll.value); + } + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + public Double getDoubleValueOfParam(String paramName) { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) return param.getDouble(systems.sdw.baseapps.Protokoll.value); + } + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + + public Long getLongValueOfParam(String paramName) { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) { + return param.getLong(systems.sdw.baseapps.Protokoll.value); + } + } + } catch (JSONException e) { + return null; + // i.e. undefined-> return null + //e.printStackTrace(); + } + return null; + } + + public Integer getIntegerValueOfParam(String paramName) { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) { + return param.getInteger(systems.sdw.baseapps.Protokoll.value); + } + } + } catch (JSONException e) { + return null; + // i.e. undefined-> return null + //e.printStackTrace(); + } + return null; + } + + + + public JSONObject getParam(String paramName) { + + for (int i=0; i<=this.length()-1; i++) { + JSONObject param; + try { + param = this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) return param; + } catch (JSONException e) { + e.printStackTrace(); + return null; + } + } + return null; + } + + + public boolean containsParam(String paramName) { + + for (int i=0; i<=this.length()-1; i++) { + JSONObject param; + try { + param = this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) return true; + } catch (JSONException e) { + e.printStackTrace(); + return false; + } + } + return false; + } + + + public Long getOIDByKlasse(String paramName) throws JSONException { + + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(paramName)) return param.getLong(systems.sdw.baseapps.Protokoll.value); + } + throw new JSONException(paramName+ " not found"); + } + + + public Long getLongValueOfItem(int pos) { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase("oidItem["+pos+"]")) return param.getLong(systems.sdw.baseapps.Protokoll.value); + } + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + public String getItemsAsStringSet() { + StringBuffer buf=new StringBuffer(); + for (int i=0; i<=this.getItemCount()-1; i++) { + if (i>0) buf.append(","); + buf.append(this.getLongValueOfItem(i).toString()); + } + return buf.toString(); + } + + + public int getItemCount() { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(systems.sdw.baseapps.Protokoll.itemCount)) return param.getLong(systems.sdw.baseapps.Protokoll.value).intValue(); + } + } catch (JSONException e) { + e.printStackTrace(); + } + return 0; + } + + public Long getOID() { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(systems.sdw.baseapps.Protokoll.param).equalsIgnoreCase(systems.sdw.baseapps.Protokoll.oid)) { + return param.getLong(systems.sdw.baseapps.Protokoll.value); + } + } + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + public String getStringValueOfParam(String paramName) { + try { + for (int i=0; i<=this.length()-1; i++) { + JSONObject param=this.getJSONObject(i); + if (param.getString(Protokoll.param).equalsIgnoreCase(paramName)) return param.getString(Protokoll.value); + } + } catch (JSONException e) { + e.printStackTrace(); + } + return null; + } + + + + + /** + * Get the object value associated with an index. + * @param index + * The index must be between 0 and length() - 1. + * @return An object value. + * @throws JSONException If there is no value for the index. + */ + public Object get(int index) throws JSONException { + Object o=opt(index); + if (o == null) { + throw new JSONException("JSONArray[" + index + "] not found."); + } + return o; + } + + + /** + * Get the boolean value associated with an index. + * The string values "true" and "false" are ocverted to boolean. + * + * public Time getTimeFromISO8601StringAPI(String paramName) throws ObjectNotFoundException { + Time value=getTimeFromISO8601String(paramName); + if (value!=null) return value; + else throw new systems.sdw.baseapps.Exceptions.ObjectNotFoundException("ISO8601String", paramName, "Ein notwendiger Parameter fehlt. Bitte ergänzen Sie diesen Parameter für den Aufruf dieses Opcodes."); + } + + + @param index The index must be between 0 and length() - 1. + * @return The truth. + * @throws JSONException If there is no value for the index or if the + * value is not ocvertable to boolean. + */ + public boolean getBoolean(int index) throws JSONException { + Object o=get(index); + if (o.equals(Boolean.FALSE) || + (o instanceof String && + ((String)o).equalsIgnoreCase("false"))) { + return false; + } else if (o.equals(Boolean.TRUE) || + (o instanceof String && + ((String)o).equalsIgnoreCase("true"))) { + return true; + } + throw new JSONException("JSONArray[" + index + "] is not a Boolean."); + } + + + /** + * Get the double value associated with an index. + * + * @param index The index must be between 0 and length() - 1. + * @return The value. + * @throws JSONException If the key is not found or if the value cannot + * be ocverted to a number. + */ + public double getDouble(int index) throws JSONException { + Object o=get(index); + try { + return o instanceof Number ? + ((Number)o).doubleValue() : + Double.valueOf((String)o).doubleValue(); + } catch (Exception e) { + throw new JSONException("JSONArray[" + index + + "] is not a number."); + } + } + + + /** + * Get the int value associated with an index. + * + * @param index The index must be between 0 and length() - 1. + * @return The value. + * @throws JSONException If the key is not found or if the value cannot + * be ocverted to a number. + * if the value cannot be ocverted to a number. + */ + public int getInt(int index) throws JSONException { + Object o=get(index); + return o instanceof Number ? + ((Number)o).intValue() : (int)getDouble(index); + } + + + /** + * Get the JSONArray associated with an index. + * @param index The index must be between 0 and length() - 1. + * @return A JSONArray value. + * @throws JSONException If there is no value for the index. or if the + * value is not a JSONArray + */ + public JSONArray getJSONArray(int index) throws JSONException { + Object o=get(index); + if (o instanceof JSONArray) { + return (JSONArray)o; + } + throw new JSONException("JSONArray[" + index + + "] is not a JSONArray."); + } + + + /** + * Get the JSONObject associated with an index. + * @param index subscript + * @return A JSONObject value. + * @throws JSONException If there is no value for the index or if the + * value is not a JSONObject + */ + public JSONObject getJSONObject(int index) throws JSONException { + Object o=get(index); + if (o instanceof JSONObject) { + return (JSONObject)o; + } + throw new JSONException("JSONArray[" + index +"] is not a JSONObject."); + } + + + /** + * Get the long value associated with an index. + * + * @param index The index must be between 0 and length() - 1. + * @return The value. + * @throws JSONException If the key is not found or if the value cannot + * be ocverted to a number. + */ + public long getLong(int index) throws JSONException { + Object o=get(index); + return o instanceof Number ? + ((Number)o).longValue() : (long)getDouble(index); + } + + + /** + * Get the string associated with an index. + * @param index The index must be between 0 and length() - 1. + * @return A string value. + * @throws JSONException If there is no value for the index. + */ + public String getString(int index) throws JSONException { + return get(index).toString(); + } + + + /** + * Determine if the value is null. + * @param index The index must be between 0 and length() - 1. + * @return true if the value at the index is null, or if there is no value. + */ + public boolean isNull(int index) { + return JSONObject.NULL.equals(opt(index)); + } + + + /** + * Make a string from the contents of this JSONArray. The + * separator string is inserted between each element. + * Warning: This method assumes that the data structure is acyclical. + * @param separator A string that will be inserted between the elements. + * @return a string. + * @throws JSONException If the array contains an invalid number. + */ + public String join(String separator) throws JSONException { + int len=length(); + StringBuffer sb=new StringBuffer(); + + for (int i=0; i < len; i += 1) { + if (i > 0) { + sb.append(separator); + } + sb.append(JSONObject.valueToString(this.myArrayList.get(i))); + } + return sb.toString(); + } + + + /** + * Get the number of elements in the JSONArray, included nulls. + * + * @return The length (or size). + */ + public int length() { + return this.myArrayList.size(); + } + + + /** + * Get the optional object value associated with an index. + * @param index The index must be between 0 and length() - 1. + * @return An object value, or null if there is no + * object at that index. + */ + public Object opt(int index) { + return (index < 0 || index >= length()) ? + null : this.myArrayList.get(index); + } + + + /** + * Get the optional boolean value associated with an index. + * It returns false if there is no value at that index, + * or if the value is not Boolean.TRUE or the String "true". + * + * @param index The index must be between 0 and length() - 1. + * @return The truth. + */ + public boolean optBoolean(int index) { + return optBoolean(index, false); + } + + + /** + * Get the optional boolean value associated with an index. + * It returns the defaultValue if there is no value at that index or if + * it is not a Boolean or the String "true" or "false" (case insensitive). + * + * @param index The index must be between 0 and length() - 1. + * @param defaultValue A boolean default. + * @return The truth. + */ + public boolean optBoolean(int index, boolean defaultValue) { + try { + return getBoolean(index); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get the optional double value associated with an index. + * NaN is returned if there is no value for the index, + * or if the value is not a number and cannot be ocverted to a number. + * + * @param index The index must be between 0 and length() - 1. + * @return The value. + */ + public double optDouble(int index) { + return optDouble(index, Double.NaN); + } + + + /** + * Get the optional double value associated with an index. + * The defaultValue is returned if there is no value for the index, + * or if the value is not a number and cannot be ocverted to a number. + * + * @param index subscript + * @param defaultValue The default value. + * @return The value. + */ + public double optDouble(int index, double defaultValue) { + try { + return getDouble(index); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get the optional int value associated with an index. + * Zero is returned if there is no value for the index, + * or if the value is not a number and cannot be ocverted to a number. + * + * @param index The index must be between 0 and length() - 1. + * @return The value. + */ + public int optInt(int index) { + return optInt(index, 0); + } + + + /** + * Get the optional int value associated with an index. + * The defaultValue is returned if there is no value for the index, + * or if the value is not a number and cannot be ocverted to a number. + * @param index The index must be between 0 and length() - 1. + * @param defaultValue The default value. + * @return The value. + */ + public int optInt(int index, int defaultValue) { + try { + return getInt(index); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get the optional JSONArray associated with an index. + * @param index subscript + * @return A JSONArray value, or null if the index has no value, + * or if the value is not a JSONArray. + */ + public JSONArray optJSONArray(int index) { + Object o=opt(index); + return o instanceof JSONArray ? (JSONArray)o : null; + } + + + /** + * Get the optional JSONObject associated with an index. + * Null is returned if the key is not found, or null if the index has + * no value, or if the value is not a JSONObject. + * + * @param index The index must be between 0 and length() - 1. + * @return A JSONObject value. + */ + public JSONObject optJSONObject(int index) { + Object o=opt(index); + return o instanceof JSONObject ? (JSONObject)o : null; + } + + + /** + * Get the optional long value associated with an index. + * Zero is returned if there is no value for the index, + * or if the value is not a number and cannot be ocverted to a number. + * + * @param index The index must be between 0 and length() - 1. + * @return The value. + */ + public long optLong(int index) { + return optLong(index, 0); + } + + + /** + * Get the optional long value associated with an index. + * The defaultValue is returned if there is no value for the index, + * or if the value is not a number and cannot be ocverted to a number. + * @param index The index must be between 0 and length() - 1. + * @param defaultValue The default value. + * @return The value. + */ + public long optLong(int index, long defaultValue) { + try { + return getLong(index); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get the optional string value associated with an index. It returns an + * empty string if there is no value at that index. If the value + * is not a string and is not null, then it is coverted to a string. + * + * @param index The index must be between 0 and length() - 1. + * @return A String value. + */ + public String optString(int index) { + return optString(index, ""); + } + + + /** + * Get the optional string associated with an index. + * The defaultValue is returned if the key is not found. + * + * @param index The index must be between 0 and length() - 1. + * @param defaultValue The default value. + * @return A String value. + */ + public String optString(int index, String defaultValue) { + Object o=opt(index); + return o != null ? o.toString() : defaultValue; + } + + + /** + * Append a boolean value. This increases the array's length by one. + * + * @param value A boolean value. + * @return this. + */ + public JSONArray put(boolean value) { + put(value ? Boolean.TRUE : Boolean.FALSE); + return this; + } + + + /** + * Put a value in the JSONArray, where the value will be a + * JSONArray which is produced from a Collection. + * @param value A Collection value. + * @return this. + */ + public JSONArray put(Collection value) { + put(new JSONArray(value)); + return this; + } + + + /** + * Append a double value. This increases the array's length by one. + * + * @param value A double value. + * @throws JSONException if the value is not finite. + * @return this. + */ + public JSONArray put(double value) throws JSONException { + Double d=Double.valueOf(value); + JSONObject.testValidity(d); + put(d); + return this; + } + + + /** + * Append an int value. This increases the array's length by one. + * + * @param value An int value. + * @return this. + */ + public JSONArray put(int value) { + put(Integer.valueOf(value)); + return this; + } + + + /** + * Append an long value. This increases the array's length by one. + * + * @param value A long value. + * @return this. + */ + public JSONArray put(long value) { + put(Long.valueOf(value)); + return this; + } + + + /** + * Put a value in the JSONArray, where the value will be a + * JSONObject which is produced from a Map. + * @param value A Map value. + * @return this. + */ + public JSONArray put(Map value) { + put(new JSONObject(value)); + return this; + } + + + /** + * Append an object value. This increases the array's length by one. + * @param value An object value. The value should be a + * Boolean, Double, Integer, JSONArray, JSONObject, Long, or String, or the + * JSONObject.NULL object. + * @return this. + */ + public JSONArray put(Object value) { + this.myArrayList.add(value); + return this; + } + + + /** + * Put or replace a boolean value in the JSONArray. If the index is greater + * than the length of the JSONArray, then null elements will be added as + * necessary to pad it out. + * @param index The subscript. + * @param value A boolean value. + * @return this. + * @throws JSONException If the index is negative. + */ + public JSONArray put(int index, boolean value) throws JSONException { + put(index, value ? Boolean.TRUE : Boolean.FALSE); + return this; + } + + + /** + * Put a value in the JSONArray, where the value will be a + * JSONArray which is produced from a Collection. + * @param index The subscript. + * @param value A Collection value. + * @return this. + * @throws JSONException If the index is negative or if the value is + * not finite. + */ + public JSONArray put(int index, Collection value) throws JSONException { + put(index, new JSONArray(value)); + return this; + } + + + /** + * Put or replace a double value. If the index is greater than the length of + * the JSONArray, then null elements will be added as necessary to pad + * it out. + * @param index The subscript. + * @param value A double value. + * @return this. + * @throws JSONException If the index is negative or if the value is + * not finite. + */ + public JSONArray put(int index, double value) throws JSONException { + put(index, Double.valueOf(value)); + return this; + } + + + /** + * Put or replace an int value. If the index is greater than the length of + * the JSONArray, then null elements will be added as necessary to pad + * it out. + * @param index The subscript. + * @param value An int value. + * @return this. + * @throws JSONException If the index is negative. + */ + public JSONArray put(int index, int value) throws JSONException { + put(index, Integer.valueOf(value)); + return this; + } + + + /** + * Put or replace a long value. If the index is greater than the length of + * the JSONArray, then null elements will be added as necessary to pad + * it out. + * @param index The subscript. + * @param value A long value. + * @return this. + * @throws JSONException If the index is negative. + */ + public JSONArray put(int index, long value) throws JSONException { + put(index, Long.valueOf(value)); + return this; + } + + + /** + * Put a value in the JSONArray, where the value will be a + * JSONObject which is produced from a Map. + * @param index The subscript. + * @param value The Map value. + * @return this. + * @throws JSONException If the index is negative or if the the value is + * an invalid number. + */ + public JSONArray put(int index, Map value) throws JSONException { + put(index, new JSONObject(value)); + return this; + } + + + /** + * Put or replace an object value in the JSONArray. If the index is greater + * than the length of the JSONArray, then null elements will be added as + * necessary to pad it out. + * @param index The subscript. + * @param value The value to put into the array. The value should be a + * Boolean, Double, Integer, JSONArray, JSONObject, Long, or String, or the + * JSONObject.NULL object. + * @return this. + * @throws JSONException If the index is negative or if the the value is + * an invalid number. + */ + public JSONArray put(int index, Object value) throws JSONException { + JSONObject.testValidity(value); + if (index < 0) { + throw new JSONException("JSONArray[" + index + "] not found."); + } + if (index < length()) { + this.myArrayList.set(index, value); + } else { + while (index != length()) { + put(JSONObject.NULL); + } + put(value); + } + return this; + } + + + /** + * Remove an index and close the hole. + * @param index The index of the element to be removed. + * @return The value that was associated with the index, + * or null if there was no value. + */ + public Object remove(int index) { + Object o=opt(index); + this.myArrayList.remove(index); + return o; + } + + + /** + * Produce a JSONObject by combining a JSONArray of names with the values + * of this JSONArray. + * @param names A JSONArray octaining a list of key strings. These will be + * paired with the values. + * @return A JSONObject, or null if there are no names or if this JSONArray + * has no values. + * @throws JSONException If any of the names are null. + */ + public JSONObject toJSONObject(JSONArray names) throws JSONException { + if (names == null || names.length() == 0 || length() == 0) { + return null; + } + JSONObject jo=new JSONObject(); + for (int i=0; i < names.length(); i += 1) { + jo.put(names.getString(i), this.opt(i)); + } + return jo; + } + + + /** + * Make a JSON text of this JSONArray. For compactness, no + * unnecessary whitespace is added. If it is not possible to produce a + * syntactically correct JSON text then null will be returned instead. This + * could occur if the array contains an invalid number. + *

+ * Warning: This method assumes that the data structure is acyclical. + * + * @return a printable, displayable, transmittable + * representation of the array. + */ + public String toString() { + try { + return '[' + join(",") + ']'; + } catch (Exception e) { + return null; + } + } + + + /** + * Make a prettyprinted JSON text of this JSONArray. + * Warning: This method assumes that the data structure is acyclical. + * @param indentFactor The number of spaces to add to each level of + * indentation. + * @return a printable, displayable, transmittable + * representation of the object, beginning + * with [ (left bracket) and ending + * with ] (right bracket). + * @throws JSONException + */ + public String toString(int indentFactor) throws JSONException { + return toString(indentFactor, 0); + } + + + /** + * Make a prettyprinted JSON text of this JSONArray. + * Warning: This method assumes that the data structure is acyclical. + * @param indentFactor The number of spaces to add to each level of + * indentation. + * @param indent The indention of the top level. + * @return a printable, displayable, transmittable + * representation of the array. + * @throws JSONException + */ + String toString(int indentFactor, int indent) throws JSONException { + int len=length(); + if (len == 0) { + return "[]"; + } + int i; + StringBuffer sb=new StringBuffer("["); + if (len == 1) { + sb.append(JSONObject.valueToString(this.myArrayList.get(0), + indentFactor, indent)); + } else { + int newindent=indent + indentFactor; + sb.append('\n'); + for (i=0; i < len; i += 1) { + if (i > 0) { + sb.append(",\n"); + } + for (int j=0; j < newindent; j += 1) { + sb.append(' '); + } + sb.append(JSONObject.valueToString(this.myArrayList.get(i), + indentFactor, newindent)); + } + sb.append('\n'); + for (i=0; i < indent; i += 1) { + sb.append(' '); + } + } + sb.append(']'); + return sb.toString(); + } + + + /** + * Write the contents of the JSONArray as JSON text to a writer. + * For compactness, no whitespace is added. + *

+ * Warning: This method assumes that the data structure is acyclical. + * + * @return The writer. + * @throws JSONException + */ + public Writer write(Writer writer) throws JSONException { + try { + boolean b=false; + int len=length(); + + writer.write('['); + + for (int i=0; i < len; i += 1) { + if (b) { + writer.write(','); + } + Object v=this.myArrayList.get(i); + if (v instanceof JSONObject) { + ((JSONObject)v).write(writer); + } else if (v instanceof JSONArray) { + ((JSONArray)v).write(writer); + } else { + writer.write(JSONObject.valueToString(v)); + } + b=true; + } + writer.write(']'); + return writer; + } catch (IOException e) { + throw new JSONException(e); + } + } +} \ No newline at end of file diff --git a/src/main/java/systems/sdw/basetech/json/JSONException.java b/src/main/java/systems/sdw/basetech/json/JSONException.java new file mode 100644 index 0000000..1fd5e04 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONException.java @@ -0,0 +1,46 @@ +package systems.sdw.basetech.json; + +/** + * The JSONException is thrown by the JSON.org classes when things are amiss. + * @author JSON.org + * @version 2008-09-18 + */ +public class JSONException extends Exception { + /** + * + */ + private static final long serialVersionUID=0; + private Throwable cause; + + /** + * Constructs a JSONException with an explanatory message. + * @param message Detail about the reason for the exception. + */ + public JSONException(String message) { + super(message); + } + + public JSONException(Throwable t) { + super(t.getMessage()); + this.cause=t; + } + + public Throwable getCause() { + return this.cause; + } + + public JSONObject get(JSONArray jsonParams, JSONObject jsonData) { + JSONObject json=new JSONObject(); + try { + json.put(systems.sdw.baseapps.Protokoll.exception, "systems.sdw.basetech.json.JSONException"); + json.put("jsonParams", jsonParams); + json.put("jsonData", jsonData); + json.put(systems.sdw.baseapps.Protokoll.klasse, this.getClass().getCanonicalName()); + json.put(systems.sdw.baseapps.Protokoll.beschreibung, "Der API-Call dieses Clients war fehlerhaft, da bestimmte Parameter erwartet, aber nicht geliefert wurden. Bitte öffnen Sie auf der Supportplattform ein neues Ticket."); + json.put(systems.sdw.baseapps.Protokoll.name, "systems.sdw.basetech.json.JSONException\njsonParams:"+jsonParams+"\njsonData:"+jsonData+"\nStacktrace:"+this.getStackTrace()); + } catch (JSONException e) { + e.printStackTrace(); + } + return json; + } +} diff --git a/src/main/java/systems/sdw/basetech/json/JSONML.java b/src/main/java/systems/sdw/basetech/json/JSONML.java new file mode 100644 index 0000000..af48100 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONML.java @@ -0,0 +1,455 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2008 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +import java.util.Iterator; + + +/** + * This provides static methods to ocvert an XML text into a JSONArray or + * JSONObject, and to covert a JSONArray or JSONObject into an XML text using + * the JsonML transform. + * @author JSON.org + * @version 2010-02-12 + */ +public class JSONML { + + /** + * Parse XML values and store them in a JSONArray. + * @param x The XMLTokener octaining the source string. + * @param arrayForm true if array form, false if object form. + * @param ja The JSONArray that is octaining the current tag or null + * if we are at the outermost level. + * @return A JSONArray if the value is the outermost tag, otherwise null. + * @throws JSONException + */ + private static Object parse(XMLTokener x, boolean arrayForm, + JSONArray ja) throws JSONException { + String attribute; + char c; + String closeTag=null; + int i; + JSONArray newja=null; + JSONObject newjo=null; + Object token; + String tagName=null; + +// Test for and skip past these forms: +// +// +// +// + + while (true) { + token=x.nextContent(); + if (token == XML.LT) { + token=x.nextToken(); + if (token instanceof Character) { + if (token == XML.SLASH) { + +// Close tag "); + } + x.back(); + } else if (c == '[') { + token=x.nextToken(); + if (token.equals("CDATA") && x.next() == '[') { + if (ja != null) { + ja.put(x.nextCDATA()); + } + } else { + throw x.syntaxError("Expected 'CDATA['"); + } + } else { + i=1; + do { + token=x.nextMeta(); + if (token == null) { + throw x.syntaxError("Missing '>' after ' 0); + } + } else if (token == XML.QUEST) { + +// "); + } else { + throw x.syntaxError("Misshaped tag"); + } + +// Open tag < + + } else { + if (!(token instanceof String)) { + throw x.syntaxError("Bad tagName '" + token + "'."); + } + tagName=(String)token; + newja=new JSONArray(); + newjo=new JSONObject(); + if (arrayForm) { + newja.put(tagName); + if (ja != null) { + ja.put(newja); + } + } else { + newjo.put("tagName", tagName); + if (ja != null) { + ja.put(newjo); + } + } + token=null; + for (;;) { + if (token == null) { + token=x.nextToken(); + } + if (token == null) { + throw x.syntaxError("Misshaped tag"); + } + if (!(token instanceof String)) { + break; + } + +// attribute=value + + attribute=(String)token; + if (!arrayForm && (attribute == "tagName" || attribute == "childNode")) { + throw x.syntaxError("Reserved attribute."); + } + token=x.nextToken(); + if (token == XML.EQ) { + token=x.nextToken(); + if (!(token instanceof String)) { + throw x.syntaxError("Missing value"); + } + newjo.accumulate(attribute, JSONObject.stringToValue((String)token)); + token=null; + } else { + newjo.accumulate(attribute, ""); + } + } + if (arrayForm && newjo.length() > 0) { + newja.put(newjo); + } + +// Empty tag <.../> + + if (token == XML.SLASH) { + if (x.nextToken() != XML.GT) { + throw x.syntaxError("Misshaped tag"); + } + if (ja == null) { + if (arrayForm) { + return newja; + } else { + return newjo; + } + } + +// Content, between <...> and + + } else { + if (token != XML.GT) { + throw x.syntaxError("Misshaped tag"); + } + closeTag=(String)parse(x, arrayForm, newja); + if (closeTag != null) { + if (!closeTag.equals(tagName)) { + throw x.syntaxError("Mismatched '" + tagName + + "' and '" + closeTag + "'"); + } + tagName=null; + if (!arrayForm && newja.length() > 0) { + newjo.put("childNodes", newja); + } + if (ja == null) { + if (arrayForm) { + return newja; + } else { + return newjo; + } + } + } + } + } + } else { + if (ja != null) { + ja.put(token instanceof String ? + JSONObject.stringToValue((String)token) : token); + } + } + } + } + + + /** + * Convert a well-formed (but not necessarily valid) XML string into a + * JSONArray using the JsonML transform. Each XML tag is represented as + * a JSONArray in which the first element is the tag name. If the tag has + * attributes, then the seocd element will be JSONObject octaining the + * name/value pairs. If the tag contains children, then strings and + * JSONArrays will represent the child tags. + * Comments, prologs, DTDs, and <[ [ ]]> are ignored. + * @param string The source string. + * @return A JSONArray octaining the structured data from the XML string. + * @throws JSONException + */ + public static JSONArray toJSONArray(String string) throws JSONException { + return toJSONArray(new XMLTokener(string)); + } + + + /** + * Convert a well-formed (but not necessarily valid) XML string into a + * JSONArray using the JsonML transform. Each XML tag is represented as + * a JSONArray in which the first element is the tag name. If the tag has + * attributes, then the seocd element will be JSONObject octaining the + * name/value pairs. If the tag contains children, then strings and + * JSONArrays will represent the child content and tags. + * Comments, prologs, DTDs, and <[ [ ]]> are ignored. + * @param x An XMLTokener. + * @return A JSONArray octaining the structured data from the XML string. + * @throws JSONException + */ + public static JSONArray toJSONArray(XMLTokener x) throws JSONException { + return (JSONArray)parse(x, true, null); + } + + + + /** + * Convert a well-formed (but not necessarily valid) XML string into a + * JSONObject using the JsonML transform. Each XML tag is represented as + * a JSONObject with a "tagName" property. If the tag has attributes, then + * the attributes will be in the JSONObject as properties. If the tag + * contains children, the object will have a "childNodes" property which + * will be an array of strings and JsonML JSONObjects. + + * Comments, prologs, DTDs, and <[ [ ]]> are ignored. + * @param x An XMLTokener of the XML source text. + * @return A JSONObject octaining the structured data from the XML string. + * @throws JSONException + */ + public static JSONObject toJSONObject(XMLTokener x) throws JSONException { + return (JSONObject)parse(x, false, null); + } + /** + * Convert a well-formed (but not necessarily valid) XML string into a + * JSONObject using the JsonML transform. Each XML tag is represented as + * a JSONObject with a "tagName" property. If the tag has attributes, then + * the attributes will be in the JSONObject as properties. If the tag + * contains children, the object will have a "childNodes" property which + * will be an array of strings and JsonML JSONObjects. + + * Comments, prologs, DTDs, and <[ [ ]]> are ignored. + * @param string The XML source text. + * @return A JSONObject octaining the structured data from the XML string. + * @throws JSONException + */ + public static JSONObject toJSONObject(String string) throws JSONException { + return toJSONObject(new XMLTokener(string)); + } + + + /** + * Reverse the JSONML transformation, making an XML text from a JSONArray. + * @param ja A JSONArray. + * @return An XML string. + * @throws JSONException + */ + public static String toString(JSONArray ja) throws JSONException { + Object e; + int i; + JSONObject jo; + String k; + Iterator keys; + int length; + StringBuffer sb=new StringBuffer(); + String tagName; + String v; + +// Emit = length) { + sb.append('/'); + sb.append('>'); + } else { + sb.append('>'); + do { + e=ja.get(i); + i += 1; + if (e != null) { + if (e instanceof String) { + sb.append(XML.escape(e.toString())); + } else if (e instanceof JSONObject) { + sb.append(toString((JSONObject)e)); + } else if (e instanceof JSONArray) { + sb.append(toString((JSONArray)e)); + } + } + } while (i < length); + sb.append('<'); + sb.append('/'); + sb.append(tagName); + sb.append('>'); + } + return sb.toString(); + } + + /** + * Reverse the JSONML transformation, making an XML text from a JSONObject. + * The JSONObject must octain a "tagName" property. If it has children, + * then it must have a "childNodes" property octaining an array of objects. + * The other properties are attributes with string values. + * @param jo A JSONObject. + * @return An XML string. + * @throws JSONException + */ + public static String toString(JSONObject jo) throws JSONException { + StringBuffer sb=new StringBuffer(); + Object e; + int i; + JSONArray ja; + String k; + Iterator keys; + int len; + String tagName; + String v; + +//Emit '); + } else { + sb.append('>'); + len=ja.length(); + for (i=0; i < len; i += 1) { + e=ja.get(i); + if (e != null) { + if (e instanceof String) { + sb.append(XML.escape(e.toString())); + } else if (e instanceof JSONObject) { + sb.append(toString((JSONObject)e)); + } else if (e instanceof JSONArray) { + sb.append(toString((JSONArray)e)); + } + } + } + sb.append('<'); + sb.append('/'); + sb.append(tagName); + sb.append('>'); + } + return sb.toString(); + } +} \ No newline at end of file diff --git a/src/main/java/systems/sdw/basetech/json/JSONObject.java b/src/main/java/systems/sdw/basetech/json/JSONObject.java new file mode 100644 index 0000000..7cebdb5 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONObject.java @@ -0,0 +1,1899 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + */ + +import java.io.IOException; +import java.io.Writer; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.Calendar; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.TreeSet; + +/** + * A JSONObject is an unordered collection of name/value pairs. Its + * external form is a string wrapped in curly braces with colons between the + * names and values, and commas between the values and names. The internal form + * is an object having get and opt methods for + * accessing the values by name, and put methods for adding or + * replacing values by name. The values can be any of these types: + * Boolean, JSONArray, JSONObject, + * Number, String, or the JSONObject.NULL + * object. A JSONObject constructor can be used to ocvert an external form + * JSON text into an internal form whose values can be retrieved with the + * get and opt methods, or to ocvert values into a + * JSON text using the put and toString methods. + * A get method returns a value if one can be found, and throws an + * exception if one cannot be found. An opt method returns a + * default value instead of throwing an exception, and so is useful for + * obtaining optional values. + *

+ * The generic get() and opt() methods return an + * object, which you can cast or query for type. There are also typed + * get and opt methods that do type checking and type + * coercion for you. + *

+ * The put methods adds values to an object. For example, 

+ *     myString=new JSONObject().put("JSON", "Hello, World!").toString();
+ * produces the string {"JSON": "Hello, World"}. + *

+ * The texts produced by the toString methods strictly ocform to + * the JSON syntax rules. + * The constructors are more forgiving in the texts they will accept: + *

    + *
  • An extra , (comma) may appear just + * before the closing brace.
    • + *
  • Strings may be quoted with ' (single + * quote).
    • + *
  • Strings do not need to be quoted at all if they do not begin with a quote + * or single quote, and if they do not octain leading or trailing spaces, + * and if they do not octain any of these characters: + * { } [ ] / \ : ,=; # and if they do not look like numbers + * and if they are not the reserved words true, + * false, or null.
    • + *
  • Keys can be followed by = or => as well as + * by :.
    • + *
  • Values can be followed by ; (semicolon) as + * well as by , (comma).
    • + *
  • Numbers may have the 0x- (hex) prefix.
    • + *
+ * @author JSON.org + * @version 2010-05-17 + */ +public class JSONObject { + + /** + * JSONObject.NULL is equivalent to the value that JavaScript calls null, + * whilst Java's null is equivalent to the value that JavaScript calls + * undefined. + */ + private static final class Null { + + /** + * There is only inended to be a single instance of the NULL object, + * so the clone method returns itself. + * @return NULL. + */ + protected final Object clone() { + return this; + } + + + /** + * A Null object is equal to the null value and to itself. + * @param object An object to test for nullness. + * @return true if the object parameter is the JSONObject.NULL object + * or null. + */ + public boolean equals(Object object) { + return object == null || object == this; + } + + + /** + * Get the "null" string value. + * @return The string "null". + */ + public String toString() { + return "null"; + } + } + + + /** + * The map where the JSONObject's properties are kept. + */ + private Map map; + + + /** + * It is sometimes more ocvenient and less ambiguous to have a + * NULL object than to use Java's null value. + * JSONObject.NULL.equals(null) returns true. + * JSONObject.NULL.toString() returns "null". + */ + public static final Object NULL=new Null(); + + + /** + * Construct an empty JSONObject. + */ + public JSONObject() { + this.map=new HashMap(); + } + + + /** + * Construct a JSONObject from a subset of another JSONObject. + * An array of strings is used to identify the keys that should be copied. + * Missing keys are ignored. + * @param jo A JSONObject. + * @param names An array of strings. + * @throws JSONException + * @exception JSONException If a value is a non-finite number or if a name is duplicated. + */ + public JSONObject(JSONObject jo, String[] names) { + this(); + for (int i=0; i < names.length; i += 1) { + try { + putOnce(names[i], jo.opt(names[i])); + } catch (Exception ignore) { + } + } + } + + + /** + * Construct a JSONObject from a JSONTokener. + * @param x A JSONTokener object octaining the source string. + * @throws JSONException If there is a syntax error in the source string + * or a duplicated key. + */ + public JSONObject(JSONTokener x) throws JSONException { + this(); + char c; + String key; + + if (x.nextClean() != '{') { + throw x.syntaxError("A JSONObject text must begin with '{'"); + } + for (;;) { + c=x.nextClean(); + switch (c) { + case 0: + throw x.syntaxError("A JSONObject text must end with '}'"); + case '}': + return; + default: + x.back(); + key=x.nextValue().toString(); + } + + /* + * The key is followed by ':'. We will also tolerate '=' or '=>'. + */ + + c=x.nextClean(); + if (c == '=') { + if (x.next() != '>') { + x.back(); + } + } else if (c != ':') { + throw x.syntaxError("Expected a ':' after a key"); + } + putOnce(key, x.nextValue()); + + /* + * Pairs are separated by ','. We will also tolerate ';'. + */ + + switch (x.nextClean()) { + case ';': + case ',': + if (x.nextClean() == '}') { + return; + } + x.back(); + break; + case '}': + return; + default: + throw x.syntaxError("Expected a ',' or '}'"); + } + } + } + + + /** + * Construct a JSONObject from a Map. + * + * @param map A map object that can be used to initialize the contents of + * the JSONObject. + * @throws JSONException + */ + public JSONObject(Map map) { + this.map=new HashMap(); + if (map != null) { + Iterator> it=map.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry e=it.next(); + this.map.put(e.getKey(), wrap(e.getValue())); + } + } + } + + + /** + * Construct a JSONObject from an Object using bean getters. + * It reflects on all of the public methods of the object. + * For each of the methods with no parameters and a name starting + * with "get" or "is" followed by an uppercase letter, + * the method is invoked, and a key and the value returned from the getter method + * are put into the new JSONObject. + * + * The key is formed by removing the "get" or "is" prefix. + * If the seocd remaining character is not upper case, then the first + * character is ocverted to lower case. + * + * For example, if an object has a method named "getName", and + * if the result of calling object.getName() is "Larry Fine", + * then the JSONObject will octain "name": "Larry Fine". + * + * @param bean An object that has getter methods that should be used + * to make a JSONObject. + */ + public JSONObject(Object bean) { + this(); + populateMap(bean); + } + + + /** + * Construct a JSONObject from an Object, using reflection to find the + * public members. The resulting JSONObject's keys will be the strings + * from the names array, and the values will be the field values associated + * with those keys in the object. If a key is not found or not visible, + * then it will not be copied into the new JSONObject. + * @param object An object that has fields that should be used to make a + * JSONObject. + * @param names An array of strings, the names of the fields to be obtained + * from the object. + */ + public JSONObject(Object object, String names[]) { + this(); + Class c=object.getClass(); + for (int i=0; i < names.length; i += 1) { + String name=names[i]; + try { + putOpt(name, c.getField(name).get(object)); + } catch (Exception ignore) { + } + } + } + + + /** + * Construct a JSONObject from a source JSON text string. + * This is the most commonly used JSONObject constructor. + * @param source A string beginning + * with { (left brace) and ending + * with } (right brace). + * @exception JSONException If there is a syntax error in the source + * string or a duplicated key. + */ + public JSONObject(String source) throws JSONException { + this(new JSONTokener(source)); + } + + + /** + * Accumulate values under a key. It is similar to the put method except + * that if there is already an object stored under the key then a + * JSONArray is stored under the key to hold all of the accumulated values. + * If there is already a JSONArray, then the new value is appended to it. + * In octrast, the put method replaces the previous value. + * @param key A key string. + * @param value An object to be accumulated under the key. + * @return this. + * @throws JSONException If the value is an invalid number + * or if the key is null. + */ + public JSONObject accumulate(String key, Object value) + throws JSONException { + testValidity(value); + Object o=opt(key); + if (o == null) { + put(key, value instanceof JSONArray ? + new JSONArray().put(value) : + value); + } else if (o instanceof JSONArray) { + ((JSONArray)o).put(value); + } else { + put(key, new JSONArray().put(o).put(value)); + } + return this; + } + + + /** + * Append values to the array under a key. If the key does not exist in the + * JSONObject, then the key is put in the JSONObject with its value being a + * JSONArray octaining the value parameter. If the key was already + * associated with a JSONArray, then the value parameter is appended to it. + * @param key A key string. + * @param value An object to be accumulated under the key. + * @return this. + * @throws JSONException If the key is null or if the current value + * associated with the key is not a JSONArray. + */ + public JSONObject append(String key, Object value) throws JSONException { + testValidity(value); + Object o=opt(key); + if (o == null) { + put(key, new JSONArray().put(value)); + } else if (o instanceof JSONArray) { + put(key, ((JSONArray)o).put(value)); + } else { + throw new JSONException("JSONObject[" + key + + "] is not a JSONArray."); + } + return this; + } + + + /** + * Produce a string from a double. The string "null" will be returned if + * the number is not finite. + * @param d A double. + * @return A String. + */ + static public String doubleToString(double d) { + if (Double.isInfinite(d) || Double.isNaN(d)) { + return "null"; + } + + // Shave off trailing zeros and decimal point, if possible. + + String s=Double.toString(d); + if (s.indexOf('.') > 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) { + while (s.endsWith("0")) { + s=s.substring(0, s.length() - 1); + } + if (s.endsWith(".")) { + s=s.substring(0, s.length() - 1); + } + } + return s; + } + + + /** + * Get the value object associated with a key. + * + * @param key A key string. + * @return The object associated with the key. + * @throws JSONException if the key is not found. + */ + public Object get(String key) throws JSONException { + Object o=opt(key); + if (o == null) { + throw new JSONException("JSONObject[" + quote(key) + + "] not found."); + } + return o; + } + + + /** + * Get the boolean value associated with a key. + * + * @param key A key string. + * @return The truth. + * @throws JSONException + * if the value is not a Boolean or the String "true" or "false". + */ + public boolean getBoolean(String key) throws JSONException { + Object o=opt(key); + if (o==null) throw new JSONException("JSONObject[" + quote(key) + + "] is not a Boolean."); + + //Object o=get(key); + if (o.equals(Boolean.FALSE) || + (o instanceof String && + ( + ((String)o).equalsIgnoreCase("false") || + ((String)o).equalsIgnoreCase("off") || + ((String)o).equalsIgnoreCase("0") + ) + ) || + (o instanceof Number && ((Integer)o)==0) + ) + {return false; } + + else if (o.equals(Boolean.TRUE) || + (o instanceof String && + ( + ((String)o).equalsIgnoreCase("true") || + ((String)o).equalsIgnoreCase("on") || + ((String)o).equalsIgnoreCase("1") + ) + ) || + (o instanceof Number && ((Integer)o)==1) + ) { + return true; + } + throw new JSONException("JSONObject[" + quote(key) + + "] is not a Boolean."); + } + + + public boolean getBoolean(String key, boolean defaultValue){ + return getBoolean(key, null, defaultValue); + } + + /** + * Get the boolean value associated with a key. + * If a currentValue is passed and the json fails is returns the currentValue + * If the currentValue is null and the json fails it returns the defaultValue + * + * @param key A key string. + * @param currentValue + * @param defaultValue + * @return The truth. + */ + public boolean getBoolean(String key, Boolean currentValue, boolean defaultValue){ + Object o=opt(key); + if (o==null) { + if(currentValue != null) return currentValue; + else return defaultValue; + } + + if (o.equals(Boolean.FALSE) || + (o instanceof String && + ( + ((String)o).equalsIgnoreCase("false") || + ((String)o).equalsIgnoreCase("off") || + ((String)o).equalsIgnoreCase("0") + ) + ) || + (o instanceof Number && ((Integer)o)==0) + ) + {return false; } + + else if (o.equals(Boolean.TRUE) || + (o instanceof String && + ( + ((String)o).equalsIgnoreCase("true") || + ((String)o).equalsIgnoreCase("on") || + ((String)o).equalsIgnoreCase("1") + ) + ) || + (o instanceof Number && ((Integer)o)==1) + ) { + return true; + } else if (currentValue != null) return currentValue; + else return defaultValue; + } + + + /** + * Get the double value associated with a key. + * @param key A key string. + * @return The numeric value. + * @throws JSONException if the key is not found or + * if the value is not a Number object and cannot be ocverted to a number. + */ + + + public double getDouble0(String key) { + Object o; + try { + o = get(key); + } catch (JSONException e1) { + return 0d; + } + try { + return o instanceof Number ? ((Number)o).doubleValue() : Double.valueOf((String)o).doubleValue(); + } catch (Exception e) { + return 0d; + } + } + + + + public Double getDouble(String key) throws JSONException { + Object o=get(key); + if (o==null) return null; + if (o instanceof JSONObject.Null) return null; + + try { + return (o instanceof Number) ? + Double.valueOf(((Number)o).doubleValue()) : + Double.valueOf((String)o).doubleValue(); + } catch (Exception e) { + String s=((String)o); + if (s.equals("")) return null; + else throw new JSONException("JSONObject[" + quote(key) + "] is not a number."); + } + } + + + /** + * Get the int value associated with a key. + * + * @param key A key string. + * @return The integer value. + * @throws JSONException if the key is not found or if the value cannot + * be ocverted to an integer. + */ + public int getInt(String key) throws JSONException { + Object o=get(key); + try { + return o instanceof Number ? + ((Number)o).intValue() : + Integer.parseInt((String)o); + } catch (Exception e) { + throw new JSONException("JSONObject[" + quote(key) + + "] is not an int."); + } + } + + /** + * Get the Integer value associated with a key. + * + * @param key A key string. + * @return The integer value. + * @throws JSONException if the key is not found or if the value cannot + * be ocverted to an integer. + */ + public Integer getInteger(String key) throws JSONException { + Object o=get(key); + // Wirft die JSON-Exception wenn der Key nicht gefunden wurde. + + if (o==null || o.toString().equalsIgnoreCase("null")) return null; + + try { + return o instanceof Number ? + ((Number)o).intValue() : + Integer.parseInt((String)o); + } catch (Exception e) { + throw new JSONException("JSONObject[" + quote(key) + + "] is not an int."); + } + } + + /** + * Get the JSONArray value associated with a key. + * + * @param key A key string. + * @return A JSONArray which is the value. + * @throws JSONException if the key is not found or + * if the value is not a JSONArray. + */ + public JSONArray getJSONArray(String key) throws JSONException { + Object o=get(key); + if (o instanceof JSONArray) { + return (JSONArray)o; + } + throw new JSONException("JSONObject[" + quote(key) +"] is not a JSONArray."); + } + + + /** + * Get the JSONObject value associated with a key. + * + * @param key A key string. + * @return A JSONObject which is the value. + * @throws JSONException if the key is not found or + * if the value is not a JSONObject. + */ + public JSONObject getJSONObject(String key) throws JSONException { + Object o=get(key); + if (o instanceof JSONObject) { + return (JSONObject)o; + } + throw new JSONException("JSONObject[" + quote(key) + + "] is not a JSONObject."); + } + + + /** + * Get the long value associated with a key. If not found or not a number return "0" + * + * @param key A key string. + * @return The long value. + */ + public Long getLong0(String key) { + Object o; + try { + o = get(key); + } catch (JSONException e1) { + return 0L; + } + + if ( o instanceof String && ((String) o).length()==0) { + return 0L; + } + + try { + return o instanceof Number ? ((Number)o).longValue() : Long.parseLong((String)o); + } catch (Exception e) { + return 0L; + } + } + + + /** + * Get the long value associated with a key. If not found or not a number throw ObjectNotFoundExeption + * + * @param key A key string. + * @return The long value. + * @throws ObjectNotFoundException + */ + // public Long getOID(String key) throws ObjectNotFoundException { + // return getLongAPI(key); + // } + // + // public Long getLongAPI(String key) throws ObjectNotFoundException { + // try { + // return getLong(key); + // } catch (JSONException e) { + // throw new systems.sdw.baseapps.Exceptions.ObjectNotFoundException(key,"Die OID für die fachliche Klasse wurde nicht im JSON-Objekt übergeben. Bitte korrigieren Sie die Parametrisierung des API-Aufrufs"); + // } + // } + + + + /** + * ALternative Klassennamen möglich, irgendeiner muss treffen. + * @param keys + * @return + * @throws JSONException + */ + public Long getLong(String[] keys) throws JSONException { + Long oid=0L; + + for (String key: keys) { + try {oid=getLong(key);} catch (JSONException ignored) {} + } + if (oid.equals(0L)) { + throw new JSONException("Die OID für alternative fachliche Klassen wurden nicht im JSON-Objekt übergeben.\nBitte korrigieren Sie die Parametrisierung des API-Aufrufs"); + } + return oid; + } + + + + public Long getLong(String key) throws JSONException { + Object o=get(key); + + if ( o instanceof String && ((String) o).length()==0) { + // leerer String abfangen + return null; + } + if ( o instanceof String && ((String) o).equalsIgnoreCase("null")) { + // leerer String abfangen + return null; + } + + try { + return o instanceof Number ? ((Number)o).longValue() : Long.parseLong((String)o); + } catch (Exception e) { + + try { + JSONObject jsonitem = (JSONObject) get(key); + o=jsonitem.get("oid"); + return o instanceof Number ? ((Number)o).longValue() : Long.parseLong((String)o); + } catch (Exception e1) { + throw new JSONException("JSONObject[" + quote(key) + "] is not a long."); + } + + } + } + + + + /** + * Get an array of field names from a JSONObject. + * + * @return An array of field names, or null if there are no names. + */ + public static String[] getNames(JSONObject jo) { + int length=jo.length(); + if (length == 0) { + return null; + } + Iterator i=jo.keys(); + String[] names=new String[length]; + int j=0; + while (i.hasNext()) { + names[j]=i.next(); + j += 1; + } + return names; + } + + + /** + * Get an array of field names from a JSONObject. + * + * @return An array of field names, or null if there are no names. + */ + public boolean containeField(String name) { + if (this.length()==0) return false; + + Iterator it=this.keys(); + while (it.hasNext()) { + if (it.next().equals(name)) return true; + } + return false; + } + + + + + /** + * Get an array of field names from an Object. + * + * @return An array of field names, or null if there are no names. + */ + public static String[] getNames(Object object) { + if (object == null) { + return null; + } + Class klass=object.getClass(); + Field[] fields=klass.getFields(); + int length=fields.length; + if (length == 0) { + return null; + } + String[] names=new String[length]; + for (int i=0; i < length; i += 1) { + names[i]=fields[i].getName(); + } + return names; + } + + + /** + * Get the string associated with a key. + * + * @param key A key string. + * @return A string which is the value. + * @throws JSONException if the key is not found. + */ + public String getString(String key) throws JSONException { + String s=get(key).toString(); + if (s.length()>0) return s; + else return null; + } + + public String getString2(String key) throws JSONException { + String s=get(key).toString(); + if (s.length()>=0) return s; + else return null; + } + + + + /** + * Get the string associated with a key. + * + * @param key A key string. + * @param defaultValue A String that is returned if key is not found + * @return A string which is the value. + * @throws JSONException if the key is not found. + */ + public String getString(String key, String defaultValue) { + String s; + try { + s = get(key).toString(); + if (s.length()>0) return s; + } catch (JSONException e) { + } + return defaultValue; + } + + public String getOptionalString(String key) { + try { + return get(key).toString(); + } catch (JSONException e) { + return ""; + } + } + + + + + + + + + + + + /** + * Zukünftig ausschließlish den ISO 8601 Standard für den Austauch von Datumsdaten nutzen!! + */ + @Deprecated + public java.sql.Date getAmericanDate(String key) throws JSONException { + String sDate=get(key).toString(); + + if (sDate==null) return null; + if (sDate.length()<10) return null; + if (sDate.equals("")) return null; + + Calendar oDatum=Calendar.getInstance(); + //oDatum.set(Calendar.DAY_OF_MONTH, new Integer(sDate.substring(0, 2)).intValue()); + //oDatum.set(Calendar.MONTH, new Integer(sDate.substring(3, 5)).intValue()-1); + //oDatum.set(Calendar.YEAR, new Integer(sDate.substring(6, 10)).intValue()); + + oDatum.set(Calendar.DAY_OF_MONTH, new Integer(sDate.substring(8, 10)).intValue()); + oDatum.set(Calendar.MONTH, new Integer(sDate.substring(5, 7)).intValue()-1); + oDatum.set(Calendar.YEAR, new Integer(sDate.substring(0, 4)).intValue()); + + + return new Date (oDatum.getTime().getTime()); + } + + + public java.sql.Time getTime(String key) throws JSONException { + String sTime=get(key).toString().trim(); + + if (sTime==null) return null; + if (sTime.equals(new String(""))) return null; + //String sTime="T10:12:00"; + Calendar oCal=Calendar.getInstance(); + oCal.set(Calendar.HOUR_OF_DAY, Integer.valueOf(sTime.substring(1, 3)).intValue()); + oCal.set(Calendar.MINUTE, Integer.valueOf(sTime.substring(4, 6)).intValue()); + oCal.set(Calendar.SECOND, 0); + + return new Time(oCal.getTime().getTime()); + } + + public java.sql.Timestamp getTimestamp(String key) throws JSONException { + String sTime=get(key).toString().trim(); + + if (sTime==null) return null; + if (sTime.equals(new String(""))) return null; + //String sTime="T10:12:00"; + Calendar oCal=Calendar.getInstance(); + oCal.set(Calendar.HOUR_OF_DAY, Integer.valueOf(sTime.substring(1, 3)).intValue()); + oCal.set(Calendar.MINUTE, Integer.valueOf(sTime.substring(4, 6)).intValue()); + oCal.set(Calendar.SECOND, 0); + + return new Timestamp(oCal.getTime().getTime()); + } + + + + + /** + * Determine if the JSONObject contains a specific key. + * @param key A key string. + * @return true if the key exists in the JSONObject. + */ + public boolean has(String key) { + return this.map.containsKey(key); + } + + + /** + * Increment a property of a JSONObject. If there is no such property, + * create one with a value of 1. If there is such a property, and if + * it is an Integer, Long, Double, or Float, then add one to it. + * @param key A key string. + * @return this. + * @throws JSONException If there is already a property with this name + * that is not an Integer, Long, Double, or Float. + */ + public JSONObject increment(String key) throws JSONException { + Object value=opt(key); + if (value == null) { + put(key, 1); + } else { + if (value instanceof Integer) { + put(key, ((Integer)value).intValue() + 1); + } else if (value instanceof Long) { + put(key, ((Long)value).longValue() + 1); + } else if (value instanceof Double) { + put(key, ((Double)value).doubleValue() + 1); + } else if (value instanceof Float) { + put(key, ((Float)value).floatValue() + 1); + } else { + throw new JSONException("Unable to increment [" + key + "]."); + } + } + return this; + } + + + /** + * Determine if the value associated with the key is null or if there is + * no value. + * @param key A key string. + * @return true if there is no value associated with the key or if + * the value is the JSONObject.NULL object. + */ + public boolean isNull(String key) { + return JSONObject.NULL.equals(opt(key)); + } + + + /** + * Get an enumeration of the keys of the JSONObject. + * + * @return An iterator of the keys. + */ + public Iterator keys() { + return this.map.keySet().iterator(); + } + + + /** + * Get the number of keys stored in the JSONObject. + * + * @return The number of keys in the JSONObject. + */ + public int length() { + return this.map.size(); + } + + + /** + * Produce a JSONArray octaining the names of the elements of this + * JSONObject. + * @return A JSONArray octaining the key strings, or null if the JSONObject + * is empty. + */ + public JSONArray names() { + JSONArray ja=new JSONArray(); + Iterator keys=keys(); + while (keys.hasNext()) { + ja.put(keys.next()); + } + return ja.length() == 0 ? null : ja; + } + + /** + * Produce a string from a Number. + * @param n A Number + * @return A String. + * @throws JSONException If n is a non-finite number. + */ + static public String numberToString(Number n) + throws JSONException { + if (n == null) { + throw new JSONException("Null pointer"); + } + testValidity(n); + + // Shave off trailing zeros and decimal point, if possible. + + String s=n.toString(); + if (s.indexOf('.') > 0 && s.indexOf('e') < 0 && s.indexOf('E') < 0) { + while (s.endsWith("0")) { + s=s.substring(0, s.length() - 1); + } + if (s.endsWith(".")) { + s=s.substring(0, s.length() - 1); + } + } + return s; + } + + + /** + * Get an optional value associated with a key. + * @param key A key string. + * @return An object which is the value, or null if there is no value. + */ + public Object opt(String key) { + return key == null ? null : this.map.get(key); + } + + + /** + * Get an optional boolean associated with a key. + * It returns false if there is no such key, or if the value is not + * Boolean.TRUE or the String "true". + * + * @param key A key string. + * @return The truth. + */ + public boolean optBoolean(String key) { + return optBoolean(key, false); + } + + + /** + * Get an optional boolean associated with a key. + * It returns the defaultValue if there is no such key, or if it is not + * a Boolean or the String "true" or "false" (case insensitive). + * + * @param key A key string. + * @param defaultValue The default. + * @return The truth. + */ + public boolean optBoolean(String key, boolean defaultValue) { + try { + return getBoolean(key); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get an optional double associated with a key, + * or NaN if there is no such key or if its value is not a number. + * If the value is a string, an attempt will be made to evaluate it as + * a number. + * + * @param key A string which is the key. + * @return An object which is the value. + */ + public double optDouble(String key) { + return optDouble(key, Double.NaN); + } + + + /** + * Get an optional double associated with a key, or the + * defaultValue if there is no such key or if its value is not a number. + * If the value is a string, an attempt will be made to evaluate it as + * a number. + * + * @param key A key string. + * @param defaultValue The default. + * @return An object which is the value. + */ + public double optDouble(String key, double defaultValue) { + try { + Object o=opt(key); + return o instanceof Number ? ((Number)o).doubleValue() : + Double.valueOf((String)o).doubleValue(); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get an optional int value associated with a key, + * or zero if there is no such key or if the value is not a number. + * If the value is a string, an attempt will be made to evaluate it as + * a number. + * + * @param key A key string. + * @return An object which is the value. + */ + public int optInt(String key) { + return optInt(key, 0); + } + + + /** + * Get an optional int value associated with a key, + * or the default if there is no such key or if the value is not a number. + * If the value is a string, an attempt will be made to evaluate it as + * a number. + * + * @param key A key string. + * @param defaultValue The default. + * @return An object which is the value. + */ + public int optInt(String key, int defaultValue) { + try { + return getInt(key); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get an optional JSONArray associated with a key. + * It returns null if there is no such key, or if its value is not a + * JSONArray. + * + * @param key A key string. + * @return A JSONArray which is the value. + */ + public JSONArray optJSONArray(String key) { + Object o=opt(key); + return o instanceof JSONArray ? (JSONArray)o : null; + } + + + /** + * Get an optional JSONObject associated with a key. + * It returns null if there is no such key, or if its value is not a + * JSONObject. + * + * @param key A key string. + * @return A JSONObject which is the value. + */ + public JSONObject optJSONObject(String key) { + Object o=opt(key); + return o instanceof JSONObject ? (JSONObject)o : null; + } + + + /** + * Get an optional long value associated with a key, + * or zero if there is no such key or if the value is not a number. + * If the value is a string, an attempt will be made to evaluate it as + * a number. + * + * @param key A key string. + * @return An object which is the value. + */ + public long optLong(String key) { + return optLong(key, 0); + } + + + /** + * Get an optional long value associated with a key, + * or the default if there is no such key or if the value is not a number. + * If the value is a string, an attempt will be made to evaluate it as + * a number. + * + * @param key A key string. + * @param defaultValue The default. + * @return An object which is the value. + */ + public long optLong(String key, long defaultValue) { + try { + return getLong(key); + } catch (Exception e) { + return defaultValue; + } + } + + + /** + * Get an optional string associated with a key. + * It returns an empty string if there is no such key. If the value is not + * a string and is not null, then it is coverted to a string. + * + * @param key A key string. + * @return A string which is the value. + */ + public String optString(String key) { + return optString(key, ""); + } + + + /** + * Get an optional string associated with a key. + * It returns the defaultValue if there is no such key. + * + * @param key A key string. + * @param defaultValue The default. + * @return A string which is the value. + */ + public String optString(String key, String defaultValue) { + Object o=opt(key); + return o != null ? o.toString() : defaultValue; + } + + private void populateMap(Object bean) { + Class klass=bean.getClass(); + + // If klass is a System class then set includeSuperClass to false. + + boolean includeSuperClass=klass.getClassLoader() != null; + + Method[] methods=(includeSuperClass) ? + klass.getMethods() : klass.getDeclaredMethods(); + for (int i=0; i < methods.length; i += 1) { + try { + Method method=methods[i]; + if (Modifier.isPublic(method.getModifiers())) { + String name=method.getName(); + String key=""; + if (name.startsWith("get")) { + if (name.equals("getClass") || + name.equals("getDeclaringClass")) { + key=""; + } else { + key=name.substring(3); + } + } else if (name.startsWith("is")) { + key=name.substring(2); + } + if (key.length() > 0 && + Character.isUpperCase(key.charAt(0)) && + method.getParameterTypes().length == 0) { + if (key.length() == 1) { + key=key.toLowerCase(); + } else if (!Character.isUpperCase(key.charAt(1))) { + key=key.substring(0, 1).toLowerCase() + + key.substring(1); + } + + Object result=method.invoke(bean, (Object[])null); + + map.put(key, wrap(result)); + } + } + } catch (Exception ignore) { + } + } + } + + + /** + * Put a key/boolean pair in the JSONObject. + * + * @param key A key string. + * @param value A boolean which is the value. + * @return this. + * @throws JSONException If the key is null. + */ + public JSONObject put(String key, boolean value) throws JSONException { + put(key, value ? Boolean.TRUE : Boolean.FALSE); + return this; + } + + + /** + * Put a key/value pair in the JSONObject, where the value will be a + * JSONArray which is produced from a Collection. + * @param key A key string. + * @param value A Collection value. + * @return this. + * @throws JSONException + */ + public JSONObject put(String key, Collection value) throws JSONException { + put(key, new JSONArray(value)); + return this; + } + + + /** + * Put a key/double pair in the JSONObject. + * + * @param key A key string. + * @param value A double which is the value. + * @return this. + * @throws JSONException If the key is null or if the number is invalid. + */ + public JSONObject put(String key, double value) throws JSONException { + put(key, Double.valueOf(value)); + return this; + } + + + /** + * Put a key/int pair in the JSONObject. + * + * @param key A key string. + * @param value An int which is the value. + * @return this. + * @throws JSONException If the key is null. + */ + public JSONObject put(String key, int value) throws JSONException { + put(key, Integer.valueOf(value)); + return this; + } + + + /** + * Put a key/long pair in the JSONObject. + * + * @param key A key string. + * @param value A long which is the value. + * @return this. + * @throws JSONException If the key is null. + */ + public JSONObject put(String key, long value) throws JSONException { + put(key, Long.valueOf(value)); + return this; + } + + + /** + * Put a key/value pair in the JSONObject, where the value will be a + * JSONObject which is produced from a Map. + * @param key A key string. + * @param value A Map value. + * @return this. + * @throws JSONException + */ + public JSONObject put(String key, Map value) throws JSONException { + put(key, new JSONObject(value)); + return this; + } + + + /** + * Put a key/value pair in the JSONObject. If the value is null, + * then the key will be removed from the JSONObject if it is present. + * @param key A key string. + * @param value An object which is the value. It should be of one of these + * types: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, + * or the JSONObject.NULL object. + * @return this. + * @throws JSONException If the value is non-finite number + * or if the key is null. + */ + public JSONObject put(String key, Object value) throws JSONException { + if (key == null) { + throw new JSONException("Null key."); + } + + if (value == null) value=new String(""); + + if (value != null) { + testValidity(value); + this.map.put(key, value); +// } else {; +// //remove(key); + } + return this; + } + + + /** + * Put a key/value pair in the JSONObject, but only if the key and the + * value are both non-null, and only if there is not already a member + * with that name. + * @param key + * @param value + * @return his. + * @throws JSONException if the key is a duplicate + */ + public JSONObject putOnce(String key, Object value) throws JSONException { + if (key != null && value != null) { + if (opt(key) != null) { + throw new JSONException("Duplicate key \"" + key + "\""); + } + put(key, value); + } + return this; + } + + + /** + * Put a key/value pair in the JSONObject, but only if the + * key and the value are both non-null. + * @param key A key string. + * @param value An object which is the value. It should be of one of these + * types: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, + * or the JSONObject.NULL object. + * @return this. + * @throws JSONException If the value is a non-finite number. + */ + public JSONObject putOpt(String key, Object value) throws JSONException { + if (key != null && value != null) { + put(key, value); + } + return this; + } + + + /** + * Produce a string in double quotes with backslash sequences in all the + * right places. A backslash will be inserted within = '\u0080' && c < '\u00a0') || + (c >= '\u2000' && c < '\u2100')) { + t="000" + Integer.toHexString(c); + sb.append("\\u" + t.substring(t.length() - 4)); + } else { + sb.append(c); + } + } + } + sb.append('"'); + return sb.toString(); + } + + /** + * Remove a name and its value, if present. + * @param key The name to be removed. + * @return The value that was associated with the name, + * or null if there was no value. + */ + public Object remove(String key) { + return this.map.remove(key); + } + + /** + * Get an enumeration of the keys of the JSONObject. + * The keys will be sorted alphabetically. + * + * @return An iterator of the keys. + */ + public Iterator sortedKeys() { + return new TreeSet(this.map.keySet()).iterator(); + } + + /** + * Try to ocvert a string into a number, boolean, or null. If the string + * can't be ocverted, return the string. + * @param s A String. + * @return A simple JSON value. + */ + static public Object stringToValue(String s) { + if (s.equals("")) { + return s; + } + if (s.equalsIgnoreCase("true")) { + return Boolean.TRUE; + } + if (s.equalsIgnoreCase("false")) { + return Boolean.FALSE; + } + if (s.equalsIgnoreCase("null")) { + return JSONObject.NULL; + } + + /* + * If it might be a number, try ocverting it. + * We support the non-standard 0x- ocvention. + * If a number cannot be produced, then the value will just + * be a string. Note that the 0x-, plus, and implied string + * ocventions are non-standard. A JSON parser may accept + * non-JSON forms as long as it accepts all correct JSON forms. + */ + + char b=s.charAt(0); + if ((b >= '0' && b <= '9') || b == '.' || b == '-' || b == '+') { + if (b == '0' && s.length() > 2 && + (s.charAt(1) == 'x' || s.charAt(1) == 'X')) { + try { + return Integer.valueOf(Integer.parseInt(s.substring(2), 16)); + } catch (Exception ignore) { + } + } + try { + if (s.indexOf('.') > -1 || + s.indexOf('e') > -1 || s.indexOf('E') > -1) { + return Double.valueOf(s); + } else { + Long myLong=Long.valueOf(s); + if (myLong.longValue() == myLong.intValue()) { + return Integer.valueOf(myLong.intValue()); + } else { + return myLong; + } + } + } catch (Exception ignore) { + } + } + return s; + } + + + /** + * Throw an exception if the object is an NaN or infinite number. + * @param o The object to test. + * @throws JSONException If o is a non-finite number. + */ + static void testValidity(Object o) throws JSONException { + if (o != null) { + if (o instanceof Double) { + if (((Double)o).isInfinite() || ((Double)o).isNaN()) { + throw new JSONException( + "JSON does not allow non-finite numbers."); + } + } else if (o instanceof Float) { + if (((Float)o).isInfinite() || ((Float)o).isNaN()) { + throw new JSONException( + "JSON does not allow non-finite numbers."); + } + } + } + } + + + /** + * Produce a JSONArray octaining the values of the members of this + * JSONObject. + * @param names A JSONArray octaining a list of key strings. This + * determines the sequence of the values in the result. + * @return A JSONArray of values. + * @throws JSONException If any of the values are non-finite numbers. + */ + public JSONArray toJSONArray(JSONArray names) throws JSONException { + if (names == null || names.length() == 0) { + return null; + } + JSONArray ja=new JSONArray(); + for (int i=0; i < names.length(); i += 1) { + ja.put(this.opt(names.getString(i))); + } + return ja; + } + + /** + * Make a JSON text of this JSONObject. For compactness, no whitespace + * is added. If this would not result in a syntactically correct JSON text, + * then null will be returned instead. + *

+ * Warning: This method assumes that the data structure is acyclical. + * + * @return a printable, displayable, portable, transmittable + * representation of the object, beginning + * with { (left brace) and ending + * with } (right brace). + */ + public String toString() { + try { + Iterator keys=keys(); + StringBuffer sb=new StringBuffer("{"); + + while (keys.hasNext()) { + if (sb.length() > 1) { + sb.append(','); + } + Object o=keys.next(); + sb.append(quote(o.toString())); + sb.append(':'); + sb.append(valueToString(this.map.get(o))); + } + sb.append('}'); + return sb.toString(); + } catch (Exception e) { + return null; + } + } + + + /** + * Make a prettyprinted JSON text of this JSONObject. + *

+ * Warning: This method assumes that the data structure is acyclical. + * @param indentFactor The number of spaces to add to each level of + * indentation. + * @return a printable, displayable, portable, transmittable + * representation of the object, beginning + * with { (left brace) and ending + * with } (right brace). + * @throws JSONException If the object contains an invalid number. + */ + public String toString(int indentFactor) throws JSONException { + return toString(indentFactor, 0); + } + + + /** + * Make a prettyprinted JSON text of this JSONObject. + *

+ * Warning: This method assumes that the data structure is acyclical. + * @param indentFactor The number of spaces to add to each level of + * indentation. + * @param indent The indentation of the top level. + * @return a printable, displayable, transmittable + * representation of the object, beginning + * with { (left brace) and ending + * with } (right brace). + * @throws JSONException If the object contains an invalid number. + */ + String toString(int indentFactor, int indent) throws JSONException { + int j; + int n=length(); + if (n == 0) { + return "{}"; + } + Iterator keys=sortedKeys(); + StringBuffer sb=new StringBuffer("{"); + int newindent=indent + indentFactor; + Object o; + if (n == 1) { + o=keys.next(); + sb.append(quote(o.toString())); + sb.append(": "); + sb.append(valueToString(this.map.get(o), indentFactor, + indent)); + } else { + while (keys.hasNext()) { + o=keys.next(); + if (sb.length() > 1) { + sb.append(",\n"); + } else { + sb.append('\n'); + } + for (j=0; j < newindent; j += 1) { + sb.append(' '); + } + sb.append(quote(o.toString())); + sb.append(": "); + sb.append(valueToString(this.map.get(o), indentFactor, + newindent)); + } + if (sb.length() > 1) { + sb.append('\n'); + for (j=0; j < indent; j += 1) { + sb.append(' '); + } + } + } + sb.append('}'); + return sb.toString(); + } + + + /** + * Make a JSON text of an Object value. If the object has an + * value.toJSONString() method, then that method will be used to produce + * the JSON text. The method is required to produce a strictly + * ocforming text. If the object does not octain a toJSONString + * method (which is the most common case), then a text will be + * produced by other means. If the value is an array or Collection, + * then a JSONArray will be made from it and its toJSONString method + * will be called. If the value is a MAP, then a JSONObject will be made + * from it and its toJSONString method will be called. Otherwise, the + * value's toString method will be called, and the result will be quoted. + * + *

+ * Warning: This method assumes that the data structure is acyclical. + * @param value The value to be serialized. + * @return a printable, displayable, transmittable + * representation of the object, beginning + * with { (left brace) and ending + * with } (right brace). + * @throws JSONException If the value is or contains an invalid number. + */ + static String valueToString(Object value) throws JSONException { + if (value == null || value.equals(null)) { + return "null"; + } + if (value instanceof JSONString) { + Object o; + try { + o=((JSONString)value).toJSONString(); + } catch (Exception e) { + throw new JSONException(e); + } + if (o instanceof String) { + return (String)o; + } + throw new JSONException("Bad value from toJSONString: " + o); + } + if (value instanceof Number) { + return numberToString((Number) value); + } + if (value instanceof Boolean || value instanceof JSONObject || + value instanceof JSONArray) { + return value.toString(); + } + if (value instanceof Map) { + return new JSONObject((Map)value).toString(); + } + if (value instanceof Collection) { + return new JSONArray((Collection)value).toString(); + } + if (value.getClass().isArray()) { + return new JSONArray(value).toString(); + } + return quote(value.toString()); + } + + + /** + * Make a prettyprinted JSON text of an object value. + *

+ * Warning: This method assumes that the data structure is acyclical. + * @param value The value to be serialized. + * @param indentFactor The number of spaces to add to each level of + * indentation. + * @param indent The indentation of the top level. + * @return a printable, displayable, transmittable + * representation of the object, beginning + * with { (left brace) and ending + * with } (right brace). + * @throws JSONException If the object contains an invalid number. + */ + static String valueToString(Object value, int indentFactor, int indent) + throws JSONException { + if (value == null || value.equals(null)) { + return "null"; + } + try { + if (value instanceof JSONString) { + Object o=((JSONString)value).toJSONString(); + if (o instanceof String) { + return (String)o; + } + } + } catch (Exception ignore) { + } + if (value instanceof Number) { + return numberToString((Number) value); + } + if (value instanceof Boolean) { + return value.toString(); + } + if (value instanceof JSONObject) { + return ((JSONObject)value).toString(indentFactor, indent); + } + if (value instanceof JSONArray) { + return ((JSONArray)value).toString(indentFactor, indent); + } + if (value instanceof Map) { + return new JSONObject((Map)value).toString(indentFactor, indent); + } + if (value instanceof Collection) { + return new JSONArray((Collection)value).toString(indentFactor, indent); + } + if (value.getClass().isArray()) { + return new JSONArray(value).toString(indentFactor, indent); + } + return quote(value.toString()); + } + + + /** + * Wrap an object, if necessary. If the object is null, return the NULL + * object. If it is an array or collection, wrap it in a JSONArray. If + * it is a map, wrap it in a JSONObject. If it is a standard property + * (Double, String, et al) then it is already wrapped. Otherwise, if it + * comes from one of the java packages, turn it into a string. And if + * it doesn't, try to wrap it in a JSONObject. If the wrapping fails, + * then null is returned. + * + * @param object The object to wrap + * @return The wrapped value + */ + static Object wrap(Object object) { + try { + if (object == null) { + return NULL; + } + if (object instanceof JSONObject || object instanceof JSONArray || + NULL.equals(object) || object instanceof JSONString || + object instanceof Byte || object instanceof Character || + object instanceof Short || object instanceof Integer || + object instanceof Long || object instanceof Boolean || + object instanceof Float || object instanceof Double || + object instanceof String) { + return object; + } + + if (object instanceof Collection) { + return new JSONArray((Collection)object); + } + if (object.getClass().isArray()) { + return new JSONArray(object); + } + if (object instanceof Map) { + return new JSONObject((Map)object); + } + Package objectPackage=object.getClass().getPackage(); + String objectPackageName=( objectPackage != null ? objectPackage.getName() : "" ); + if (objectPackageName.startsWith("java.") || + objectPackageName.startsWith("javax.") || + object.getClass().getClassLoader() == null) { + return object.toString(); + } + return new JSONObject(object); + } catch(Exception exception) { + return null; + } + } + + + /** + * Write the contents of the JSONObject as JSON text to a writer. + * For compactness, no whitespace is added. + *

+ * Warning: This method assumes that the data structure is acyclical. + * + * @return The writer. + * @throws JSONException + */ + public Writer write(Writer writer) throws JSONException { + try { + boolean b=false; + Iterator keys=keys(); + writer.write('{'); + + while (keys.hasNext()) { + if (b) { + writer.write(','); + } + Object k=keys.next(); + writer.write(quote(k.toString())); + writer.write(':'); + Object v=this.map.get(k); + if (v instanceof JSONObject) { + ((JSONObject)v).write(writer); + } else if (v instanceof JSONArray) { + ((JSONArray)v).write(writer); + } else { + writer.write(valueToString(v)); + } + b=true; + } + writer.write('}'); + return writer; + } catch (IOException exception) { + throw new JSONException(exception); + } + } + + + +} \ No newline at end of file diff --git a/src/main/java/systems/sdw/basetech/json/JSONString.java b/src/main/java/systems/sdw/basetech/json/JSONString.java new file mode 100644 index 0000000..28f1779 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONString.java @@ -0,0 +1,18 @@ +package systems.sdw.basetech.json; +/** + * The JSONString interface allows a toJSONString() + * method so that a class can change the behavior of + * JSONObject.toString(), JSONArray.toString(), + * and JSONWriter.value(Object). The + * toJSONString method will be used instead of the default behavior + * of using the Object's toString() method and quoting the result. + */ +public interface JSONString { + /** + * The toJSONString method allows a class to produce its own JSON + * serialization. + * + * @return A strictly syntactically correct JSON text. + */ + public String toJSONString(); +} diff --git a/src/main/java/systems/sdw/basetech/json/JSONStringer.java b/src/main/java/systems/sdw/basetech/json/JSONStringer.java new file mode 100644 index 0000000..726bf29 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONStringer.java @@ -0,0 +1,78 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2006 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +import java.io.StringWriter; + +/** + * JSONStringer provides a quick and ocvenient way of producing JSON text. + * The texts produced strictly ocform to JSON syntax rules. No whitespace is + * added, so the results are ready for transmission or storage. Each instance of + * JSONStringer can produce one JSON text. + *

+ * A JSONStringer instance provides a value method for appending + * values to the + * text, and a key + * method for adding keys before values in objects. There are array + * and endArray methods that make and bound array values, and + * object and endObject methods which make and bound + * object values. All of these methods return the JSONWriter instance, + * permitting cascade style. For example, 

+ * myString=new JSONStringer()
+ *     .object()
+ *         .key("JSON")
+ *         .value("Hello, World!")
+ *     .endObject()
+ *     .toString();
which produces the string 
+ * {"JSON":"Hello, World!"}
+ *

+ * The first method called must be array or object. + * There are no methods for adding commas or colons. JSONStringer adds them for + * you. Objects and arrays can be nested up to 20 levels deep. + *

+ * This can sometimes be easier than using a JSONObject to build a string. + * @author JSON.org + * @version 2008-09-18 + */ +public class JSONStringer extends JSONWriter { + /** + * Make a fresh JSONStringer. It can be used to build one JSON text. + */ + public JSONStringer() { + super(new StringWriter()); + } + + /** + * Return the JSON text. This method is used to obtain the product of the + * JSONStringer instance. It will return null if there was a + * problem in the ocstruction of the JSON text (such as the calls to + * array were not properly balanced with calls to + * endArray). + * @return The JSON text. + */ + public String toString() { + return this.mode == 'd' ? this.writer.toString() : null; + } +} diff --git a/src/main/java/systems/sdw/basetech/json/JSONTokener.java b/src/main/java/systems/sdw/basetech/json/JSONTokener.java new file mode 100644 index 0000000..1eeb6c0 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONTokener.java @@ -0,0 +1,435 @@ +package systems.sdw.basetech.json; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.Reader; +import java.io.StringReader; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/** + * A JSONTokener takes a source string and extracts characters and tokens from + * it. It is used by the JSONObject and JSONArray constructor to parse + * JSON source strings. + * @author JSON.org + * @version 2010-02-02 + */ +public class JSONTokener { + + private int character; + private boolean eof; + private int index; + private int line; + private char previous; + private Reader reader; + private boolean usePrevious; + + + /** + * Construct a JSONTokener from a reader. + * + * @param reader A reader. + */ + public JSONTokener(Reader reader) { + this.reader=reader.markSupported() ? + reader : new BufferedReader(reader); + this.eof=false; + this.usePrevious=false; + this.previous=0; + this.index=0; + this.character=1; + this.line=1; + } + + + /** + * Construct a JSONTokener from a string. + * + * @param s A source string. + */ + public JSONTokener(String s) { + this(new StringReader(s)); + } + + + /** + * Back up one character. This provides a ort of lookahead capability, + * so that you can test for a digit or letter before attempting to parse + * the next number or identifier. + */ + public void back() throws JSONException { + if (usePrevious || index <= 0) { + throw new JSONException("Stepping back two steps is not supported"); + } + this.index -= 1; + this.character -= 1; + this.usePrevious=true; + this.eof=false; + } + + + /** + * Get the hex value of a character (base16). + * @param c A character between '0' and '9' or between 'A' and 'F' or + * between 'a' and 'f'. + * @return An int between 0 and 15, or -1 if c was not a hex digit. + */ + public static int dehexchar(char c) { + if (c >= '0' && c <= '9') { + return c - '0'; + } + if (c >= 'A' && c <= 'F') { + return c - ('A' - 10); + } + if (c >= 'a' && c <= 'f') { + return c - ('a' - 10); + } + return -1; + } + + public boolean end() { + return eof && !usePrevious; + } + + + /** + * Determine if the source string still contains characters that next() + * can ocsume. + * @return true if not yet at the end of the source. + */ + public boolean more() throws JSONException { + next(); + if (end()) { + return false; + } + back(); + return true; + } + + + /** + * Get the next character in the source string. + * + * @return The next character, or 0 if past the end of the source string. + */ + public char next() throws JSONException { + int c; + if (this.usePrevious) { + this.usePrevious=false; + c=this.previous; + } else { + try { + c=this.reader.read(); + } catch (IOException exception) { + throw new JSONException(exception); + } + + if (c <= 0) { // End of stream + this.eof=true; + c=0; + } + } + this.index += 1; + if (this.previous == '\r') { + this.line += 1; + this.character=c == '\n' ? 0 : 1; + } else if (c == '\n') { + this.line += 1; + this.character=0; + } else { + this.character += 1; + } + this.previous=(char) c; + return this.previous; + } + + + /** + * Consume the next character, and check that it matches a specified + * character. + * @param c The character to match. + * @return The character. + * @throws JSONException if the character does not match. + */ + public char next(char c) throws JSONException { + char n=next(); + if (n != c) { + throw syntaxError("Expected '" + c + "' and instead saw '" + + n + "'"); + } + return n; + } + + + /** + * Get the next n characters. + * + * @param n The number of characters to take. + * @return A string of n characters. + * @throws JSONException + * Substring bounds error if there are not + * n characters remaining in the source string. + */ + public String next(int n) throws JSONException { + if (n == 0) { + return ""; + } + + char[] buffer=new char[n]; + int pos=0; + + while (pos < n) { + buffer[pos]=next(); + if (end()) { + throw syntaxError("Substring bounds error"); + } + pos += 1; + } + return new String(buffer); + } + + + /** + * Get the next char in the string, skipping whitespace. + * @throws JSONException + * @return A character, or 0 if there are no more characters. + */ + public char nextClean() throws JSONException { + for (;;) { + char c=next(); + if (c == 0 || c > ' ') { + return c; + } + } + } + + + /** + * Return the characters up to the next close quote character. + * Backslash processing is done. The formal JSON format does not + * allow strings in single quotes, but an implementation is allowed to + * accept them. + * @param quote The quoting character, either + * " (double quote) or + * ' (single quote). + * @return A String. + * @throws JSONException Unterminated string. + */ + public String nextString(char quote) throws JSONException { + char c; + StringBuffer sb=new StringBuffer(); + for (;;) { + c=next(); + switch (c) { + case 0: + case '\n': + case '\r': + throw syntaxError("Unterminated string"); + case '\\': + c=next(); + switch (c) { + case 'b': + sb.append('\b'); + break; + case 't': + sb.append('\t'); + break; + case 'n': + sb.append('\n'); + break; + case 'f': + sb.append('\f'); + break; + case 'r': + sb.append('\r'); + break; + case 'u': + sb.append((char)Integer.parseInt(next(4), 16)); + break; + case '"': + case '\'': + case '\\': + case '/': + sb.append(c); + break; + default: + throw syntaxError("Illegal escape."); + } + break; + default: + if (c == quote) { + return sb.toString(); + } + sb.append(c); + } + } + } + + + /** + * Get the text up but not including the specified character or the + * end of line, whichever comes first. + * @param d A delimiter character. + * @return A string. + */ + public String nextTo(char d) throws JSONException { + StringBuffer sb=new StringBuffer(); + for (;;) { + char c=next(); + if (c == d || c == 0 || c == '\n' || c == '\r') { + if (c != 0) { + back(); + } + return sb.toString().trim(); + } + sb.append(c); + } + } + + + /** + * Get the text up but not including one of the specified delimiter + * characters or the end of line, whichever comes first. + * @param delimiters A set of delimiter characters. + * @return A string, trimmed. + */ + public String nextTo(String delimiters) throws JSONException { + char c; + StringBuffer sb=new StringBuffer(); + for (;;) { + c=next(); + if (delimiters.indexOf(c) >= 0 || c == 0 || + c == '\n' || c == '\r') { + if (c != 0) { + back(); + } + return sb.toString().trim(); + } + sb.append(c); + } + } + + + /** + * Get the next value. The value can be a Boolean, Double, Integer, + * JSONArray, JSONObject, Long, or String, or the JSONObject.NULL object. + * @throws JSONException If syntax error. + * + * @return An object. + */ + public Object nextValue() throws JSONException { + char c=nextClean(); + String s; + + switch (c) { + case '"': + case '\'': + return nextString(c); + case '{': + back(); + return new JSONObject(this); + case '[': + case '(': + back(); + return new JSONArray(this); + } + + /* + * Handle unquoted text. This could be the values true, false, or + * null, or it can be a number. An implementation (such as this one) + * is allowed to also accept non-standard forms. + * + * Accumulate characters until we reach the end of the text or a + * formatting character. + */ + + StringBuffer sb=new StringBuffer(); + while (c >= ' ' && ",:]}/\\\"[{;=#".indexOf(c) < 0) { + sb.append(c); + c=next(); + } + back(); + + s=sb.toString().trim(); + if (s.equals("")) { + throw syntaxError("Missing value"); + } + return JSONObject.stringToValue(s); + } + + + /** + * Skip characters until the next character is the requested character. + * If the requested character is not found, no characters are skipped. + * @param to A character to skip to. + * @return The requested character, or zero if the requested character + * is not found. + */ + public char skipTo(char to) throws JSONException { + char c; + try { + int startIndex=this.index; + int startCharacter=this.character; + int startLine=this.line; + reader.mark(Integer.MAX_VALUE); + do { + c=next(); + if (c == 0) { + reader.reset(); + this.index=startIndex; + this.character=startCharacter; + this.line=startLine; + return c; + } + } while (c != to); + } catch (IOException exc) { + throw new JSONException(exc); + } + + back(); + return c; + } + + + /** + * Make a JSONException to signal a syntax error. + * + * @param message The error message. + * @return A JSONException object, suitable for throwing + */ + public JSONException syntaxError(String message) { + return new JSONException(message + toString()); + } + + + /** + * Make a printable string of this JSONTokener. + * + * @return " at {index} [character {character} line {line}]" + */ + public String toString() { + return " at " + index + " [character " + this.character + " line " + this.line + "]"; + } +} \ No newline at end of file diff --git a/src/main/java/systems/sdw/basetech/json/JSONWriter.java b/src/main/java/systems/sdw/basetech/json/JSONWriter.java new file mode 100644 index 0000000..8139660 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/JSONWriter.java @@ -0,0 +1,323 @@ +package systems.sdw.basetech.json; + +import java.io.IOException; +import java.io.Writer; + +/* +Copyright (c) 2006 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/** + * JSONWriter provides a quick and ocvenient way of producing JSON text. + * The texts produced strictly ocform to JSON syntax rules. No whitespace is + * added, so the results are ready for transmission or storage. Each instance of + * JSONWriter can produce one JSON text. + *

+ * A JSONWriter instance provides a value method for appending + * values to the + * text, and a key + * method for adding keys before values in objects. There are array + * and endArray methods that make and bound array values, and + * object and endObject methods which make and bound + * object values. All of these methods return the JSONWriter instance, + * permitting a cascade style. For example, 

+ * new JSONWriter(myWriter)
+ *     .object()
+ *         .key("JSON")
+ *         .value("Hello, World!")
+ *     .endObject();
which writes 
+ * {"JSON":"Hello, World!"}
+ *

+ * The first method called must be array or object. + * There are no methods for adding commas or colons. JSONWriter adds them for + * you. Objects and arrays can be nested up to 20 levels deep. + *

+ * This can sometimes be easier than using a JSONObject to build a string. + * @author JSON.org + * @version 2010-03-11 + */ +public class JSONWriter { + private static final int maxdepth=20; + + /** + * The comma flag determines if a comma should be output before the next + * value. + */ + private boolean comma; + + /** + * The current mode. Values: + * 'a' (array), + * 'd' (done), + * 'i' (initial), + * 'k' (key), + * 'o' (object). + */ + protected char mode; + + /** + * The object/array stack. + */ + private JSONObject stack[]; + + /** + * The stack top index. A value of 0 indicates that the stack is empty. + */ + private int top; + + /** + * The writer that will receive the output. + */ + protected Writer writer; + + /** + * Make a fresh JSONWriter. It can be used to build one JSON text. + */ + public JSONWriter(Writer w) { + this.comma=false; + this.mode='i'; + this.stack=new JSONObject[maxdepth]; + this.top=0; + this.writer=w; + } + + /** + * Append a value. + * @param s A string value. + * @return this + * @throws JSONException If the value is out of sequence. + */ + private JSONWriter append(String s) throws JSONException { + if (s == null) { + throw new JSONException("Null pointer"); + } + if (this.mode == 'o' || this.mode == 'a') { + try { + if (this.comma && this.mode == 'a') { + this.writer.write(','); + } + this.writer.write(s); + } catch (IOException e) { + throw new JSONException(e); + } + if (this.mode == 'o') { + this.mode='k'; + } + this.comma=true; + return this; + } + throw new JSONException("Value out of sequence."); + } + + /** + * Begin appending a new array. All values until the balancing + * endArray will be appended to this array. The + * endArray method must be called to mark the array's end. + * @return this + * @throws JSONException If the nesting is too deep, or if the object is + * started in the wrong place (for example as a key or after the end of the + * outermost array or object). + */ + public JSONWriter array() throws JSONException { + if (this.mode == 'i' || this.mode == 'o' || this.mode == 'a') { + this.push(null); + this.append("["); + this.comma=false; + return this; + } + throw new JSONException("Misplaced array."); + } + + /** + * End something. + * @param m Mode + * @param c Closing character + * @return this + * @throws JSONException If unbalanced. + */ + private JSONWriter end(char m, char c) throws JSONException { + if (this.mode != m) { + throw new JSONException(m == 'a' ? "Misplaced endArray." : + "Misplaced endObject."); + } + this.pop(m); + try { + this.writer.write(c); + } catch (IOException e) { + throw new JSONException(e); + } + this.comma=true; + return this; + } + + /** + * End an array. This method most be called to balance calls to + * array. + * @return this + * @throws JSONException If incorrectly nested. + */ + public JSONWriter endArray() throws JSONException { + return this.end('a', ']'); + } + + /** + * End an object. This method most be called to balance calls to + * object. + * @return this + * @throws JSONException If incorrectly nested. + */ + public JSONWriter endObject() throws JSONException { + return this.end('k', '}'); + } + + /** + * Append a key. The key will be associated with the next value. In an + * object, every value must be preceded by a key. + * @param s A key string. + * @return this + * @throws JSONException If the key is out of place. For example, keys + * do not belong in arrays or if the key is null. + */ + public JSONWriter key(String s) throws JSONException { + if (s == null) { + throw new JSONException("Null key."); + } + if (this.mode == 'k') { + try { + stack[top - 1].putOnce(s, Boolean.TRUE); + if (this.comma) { + this.writer.write(','); + } + this.writer.write(JSONObject.quote(s)); + this.writer.write(':'); + this.comma=false; + this.mode='o'; + return this; + } catch (IOException e) { + throw new JSONException(e); + } + } + throw new JSONException("Misplaced key."); + } + + + /** + * Begin appending a new object. All keys and values until the balancing + * endObject will be appended to this object. The + * endObject method must be called to mark the object's end. + * @return this + * @throws JSONException If the nesting is too deep, or if the object is + * started in the wrong place (for example as a key or after the end of the + * outermost array or object). + */ + public JSONWriter object() throws JSONException { + if (this.mode == 'i') { + this.mode='o'; + } + if (this.mode == 'o' || this.mode == 'a') { + this.append("{"); + this.push(new JSONObject()); + this.comma=false; + return this; + } + throw new JSONException("Misplaced object."); + + } + + + /** + * Pop an array or object scope. + * @param c The scope to close. + * @throws JSONException If nesting is wrong. + */ + private void pop(char c) throws JSONException { + if (this.top <= 0) { + throw new JSONException("Nesting error."); + } + char m=this.stack[this.top - 1] == null ? 'a' : 'k'; + if (m != c) { + throw new JSONException("Nesting error."); + } + this.top -= 1; + this.mode=this.top == 0 ? 'd' : this.stack[this.top - 1] == null ? 'a' : 'k'; + } + + /** + * Push an array or object scope. + * @param c The scope to open. + * @throws JSONException If nesting is too deep. + */ + private void push(JSONObject jo) throws JSONException { + if (this.top >= maxdepth) { + throw new JSONException("Nesting too deep."); + } + this.stack[this.top]=jo; + this.mode=jo == null ? 'a' : 'k'; + this.top += 1; + } + + + /** + * Append either the value true or the value + * false. + * @param b A boolean. + * @return this + * @throws JSONException + */ + public JSONWriter value(boolean b) throws JSONException { + return this.append(b ? "true" : "false"); + } + + /** + * Append a double value. + * @param d A double. + * @return this + * @throws JSONException If the number is not finite. + */ + public JSONWriter value(double d) throws JSONException { + return this.value(Double.valueOf(d)); + } + + /** + * Append a long value. + * @param l A long. + * @return this + * @throws JSONException + */ + public JSONWriter value(long l) throws JSONException { + return this.append(Long.toString(l)); + } + + + /** + * Append an object value. + * @param o The object to append. It can be null, or a Boolean, Number, + * String, JSONObject, or JSONArray, or an object with a toJSONString() + * method. + * @return this + * @throws JSONException If the value is out of sequence. + */ + public JSONWriter value(Object o) throws JSONException { + return this.append(JSONObject.valueToString(o)); + } +} diff --git a/src/main/java/systems/sdw/basetech/json/Test.java b/src/main/java/systems/sdw/basetech/json/Test.java new file mode 100644 index 0000000..8abc858 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/Test.java @@ -0,0 +1,678 @@ +package systems.sdw.basetech.json; + +import java.util.Collection; +import java.util.Iterator; +import java.util.Map; +import java.io.StringWriter; + +/** + * Test class. This file is not formally a member of the org.json library. + * It is just a casual test tool. + */ +public class Test { + + /** + * Entry point. + * @param args + */ + public static void main(String args[]) { + Iterator it; + JSONArray a; + JSONObject j; + JSONStringer jj; + Object o; + String s; + +/** + * Obj is a typical class that implements JSONString. It also + * provides some beanie methods that can be used to + * ocstruct a JSONObject. It also demonstrates ocstructing + * a JSONObject with an array of names. + */ + class Obj implements JSONString { + public String aString; + public double aNumber; + public boolean aBoolean; + + public Obj(String string, double n, boolean b) { + this.aString=string; + this.aNumber=n; + this.aBoolean=b; + } + + public double getNumber() { + return this.aNumber; + } + + public String getString() { + return this.aString; + } + + public boolean isBoolean() { + return this.aBoolean; + } + + public String getBENT() { + return "All uppercase key"; + } + + public String getX() { + return "x"; + } + + public String toJSONString() { + return "{" + JSONObject.quote(this.aString) + ":" + + JSONObject.doubleToString(this.aNumber) + "}"; + } + public String toString() { + return this.getString() + " " + this.getNumber() + " " + + this.isBoolean() + "." + this.getBENT() + " " + this.getX(); + } + } + + + Obj obj=new Obj("A beany object", 42, true); + + try { + s="[0.1]"; + a=new JSONArray(s); + System.out.println(a.toString()); + System.out.println(""); + + j=XML.toJSONObject(" Ignore the stuff past the end. "); + System.out.println(j.toString()); + System.out.println(""); + + j=new JSONObject(); + o=null; + j.put("booga", o); + j.put("wooga", JSONObject.NULL); + System.out.println(j.toString()); + System.out.println(""); + + j=new JSONObject(); + j.increment("two"); + j.increment("two"); + System.out.println(j.toString()); + System.out.println(""); + + + s=""; + j=XML.toJSONObject(s); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + s="{ \"list of lists\" : [ [1, 2, 3], [4, 5, 6], ] }"; + j=new JSONObject(s); + System.out.println(j.toString(4)); + System.out.println(XML.toString(j)); + + s=" Basic bread Flour Yeast Water Salt Mix all ingredients together. Knead thoroughly. Cover with a cloth, and leave for one hour in warm room. Knead again. Place in a bread baking tin. Cover with a cloth, and leave for one hour in warm room. Bake in the oven at 180(degrees)C for 30 minutes. "; + j=XML.toJSONObject(s); + System.out.println(j.toString(4)); + System.out.println(); + + j=JSONML.toJSONObject(s); + System.out.println(j.toString()); + System.out.println(JSONML.toString(j)); + System.out.println(); + + a=JSONML.toJSONArray(s); + System.out.println(a.toString(4)); + System.out.println(JSONML.toString(a)); + System.out.println(); + + s="

JSONML is a transformation between JSON and XML that preserves ordering of document features.

JSONML can work with JSON arrays or JSON objects.

Three
little
words

"; + j=JSONML.toJSONObject(s); + System.out.println(j.toString(4)); + System.out.println(JSONML.toString(j)); + System.out.println(); + + a=JSONML.toJSONArray(s); + System.out.println(a.toString(4)); + System.out.println(JSONML.toString(a)); + System.out.println(); + + s="\n Robert\n Smith\n
\n 12345 Sixth Ave\n Anytown\n CA\n 98765-4321\n
\n "; + j=XML.toJSONObject(s); + System.out.println(j.toString(4)); + + j=new JSONObject(obj); + System.out.println(j.toString()); + + s="{ \"entity\": { \"imageURL\": \"\", \"name\": \"IXXXXXXXXXXXXX\", \"id\": 12336, \"ratingCount\": null, \"averageRating\": null } }"; + j=new JSONObject(s); + System.out.println(j.toString(2)); + + jj=new JSONStringer(); + s=jj + .object() + .key("single") + .value("MARIE HAA'S") + .key("Johnny") + .value("MARIE HAA\\'S") + .key("foo") + .value("bar") + .key("baz") + .array() + .object() + .key("quux") + .value("Thanks, Josh!") + .endObject() + .endArray() + .key("obj keys") + .value(JSONObject.getNames(obj)) + .endObject() + .toString(); + System.out.println(s); + + System.out.println(new JSONStringer() + .object() + .key("a") + .array() + .array() + .array() + .value("b") + .endArray() + .endArray() + .endArray() + .endObject() + .toString()); + + jj=new JSONStringer(); + jj.array(); + jj.value(1); + jj.array(); + jj.value(null); + jj.array(); + jj.object(); + jj.key("empty-array").array().endArray(); + jj.key("answer").value(42); + jj.key("null").value(null); + jj.key("false").value(false); + jj.key("true").value(true); + jj.key("big").value(123456789e+88); + jj.key("small").value(123456789e-88); + jj.key("empty-object").object().endObject(); + jj.key("long"); + jj.value(9223372036854775807L); + jj.endObject(); + jj.value("two"); + jj.endArray(); + jj.value(true); + jj.endArray(); + jj.value(98.6); + jj.value(-100.0); + jj.object(); + jj.endObject(); + jj.object(); + jj.key("one"); + jj.value(1.00); + jj.endObject(); + jj.value(obj); + jj.endArray(); + System.out.println(jj.toString()); + + System.out.println(new JSONArray(jj.toString()).toString(4)); + + int ar[]={1, 2, 3}; + JSONArray ja=new JSONArray(ar); + System.out.println(ja.toString()); + + String sa[]={"aString", "aNumber", "aBoolean"}; + j=new JSONObject(obj, sa); + j.put("Testing JSONString interface", obj); + System.out.println(j.toString(4)); + + j=new JSONObject("{slashes: '///', closetag: '', backslash:'\\\\', ei: {quotes: '\"\\''},eo: {a: '\"quoted\"', b:\"don't\"}, quotes: [\"'\", '\"']}"); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=new JSONObject( + "{foo: [true, false,9876543210, 0.0, 1.00000001, 1.000000000001, 1.00000000000000001," + + " .00000000000000001, 2.00, 0.1, 2e100, -32,[],{}, \"string\"], " + + " to : null, op : 'Good'," + + "ten:10} postfix comment"); + j.put("String", "98.6"); + j.put("JSONObject", new JSONObject()); + j.put("JSONArray", new JSONArray()); + j.put("int", 57); + j.put("double", 123456789012345678901234567890.); + j.put("true", true); + j.put("false", false); + j.put("null", JSONObject.NULL); + j.put("bool", "true"); + j.put("zero", -0.0); + j.put("\\u2028", "\u2028"); + j.put("\\u2029", "\u2029"); + a=j.getJSONArray("foo"); + a.put(666); + a.put(2001.99); + a.put("so \"fine\"."); + a.put("so ."); + a.put(true); + a.put(false); + a.put(new JSONArray()); + a.put(new JSONObject()); + j.put("keys", JSONObject.getNames(j)); + System.out.println(j.toString(4)); + System.out.println(XML.toString(j)); + + System.out.println("String: " + j.getDouble("String")); + System.out.println(" bool: " + j.getBoolean("bool")); + System.out.println(" to: " + j.getString("to")); + System.out.println(" true: " + j.getString("true")); + System.out.println(" foo: " + j.getJSONArray("foo")); + System.out.println(" op: " + j.getString("op")); + System.out.println(" ten: " + j.getInt("ten")); + System.out.println(" oops: " + j.optBoolean("oops")); + + s="First \u0009<content> This is \"content\". 3 JSON does not preserve the sequencing of elements and contents. III T H R E EContent text is an implied structure in XML. JSON does not have implied structure:7everything is explicit.!]]>"; + j=XML.toJSONObject(s); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + ja=JSONML.toJSONArray(s); + System.out.println(ja.toString(4)); + System.out.println(JSONML.toString(ja)); + System.out.println(""); + + s="unodostrestruequatrocinqoseis"; + ja=JSONML.toJSONArray(s); + System.out.println(ja.toString(4)); + System.out.println(JSONML.toString(ja)); + System.out.println(""); + + s=" "; + j=XML.toJSONObject(s); + + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + ja=JSONML.toJSONArray(s); + System.out.println(ja.toString(4)); + System.out.println(JSONML.toString(ja)); + System.out.println(""); + + j=XML.toJSONObject("Sample BookThis is chapter 1. It is not very long or interesting.This is chapter 2. Although it is longer than chapter 1, it is not any more interesting."); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=XML.toJSONObject(""); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=XML.toJSONObject(" Fred fbs0001 Scerbo B "); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=XML.toJSONObject("Repository Address Special Collections LibraryABC UniversityMain Library, 40 Circle DriveOurtown, Pennsylvania17654 USA"); + System.out.println(j.toString()); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=XML.toJSONObject("deluxe&"toot"&toot;Aeksbonusbonus2"); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=HTTP.toJSONObject("GET / HTTP/1.0\nAccept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-powerpoint, application/vnd.ms-excel, application/msword, */*\nAccept-Language: en-us\nUser-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows 98; Win 9x 4.90; T312461; Q312461)\nHost: www.nokko.com\nObjectcontroller: keep-alive\nAccept-encoding: gzip, deflate\n"); + System.out.println(j.toString(2)); + System.out.println(HTTP.toString(j)); + System.out.println(""); + + j=HTTP.toJSONObject("HTTP/1.1 200 Oki Doki\nDate: Sun, 26 May 2002 17:38:52 GMT\nServer: Apache/1.3.23 (Unix) mod_perl/1.26\nKeep-Alive: timeout=15, max=100\nObjectcontroller: Keep-Alive\nTransfer-Encoding: chunked\nContent-Type: text/html\n"); + System.out.println(j.toString(2)); + System.out.println(HTTP.toString(j)); + System.out.println(""); + + j=new JSONObject("{nix: null, nux: false, null: 'null', 'Request-URI': '/', Method: 'GET', 'HTTP-Version': 'HTTP/1.0'}"); + System.out.println(j.toString(2)); + System.out.println("isNull: " + j.isNull("nix")); + System.out.println(" has: " + j.has("nix")); + System.out.println(XML.toString(j)); + System.out.println(HTTP.toString(j)); + System.out.println(""); + + j=XML.toJSONObject(""+"\n\n"+""+ + ""+ + "GOOGLEKEY '+search+' 0 10 true false latin1 latin1"+ + ""+ + ""); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=new JSONObject("{Envelope: {Body: {\"ns1:doGoogleSearch\": {oe: \"latin1\", filter: true, q: \"'+search+'\", key: \"GOOGLEKEY\", maxResults: 10, \"SOAP-ENV:encodingStyle\": \"http://schemas.xmlsoap.org/soap/encoding/\", start: 0, ie: \"latin1\", safeSearch:false, \"xmlns:ns1\": \"urn:GoogleSearch\"}}}}"); + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + + j=CookieList.toJSONObject(" f%oo=b+l=ah ; o;n%40e=t.wo "); + System.out.println(j.toString(2)); + System.out.println(CookieList.toString(j)); + System.out.println(""); + + j=Cookie.toJSONObject("f%oo=blah; secure ;expires=April 24, 2002"); + System.out.println(j.toString(2)); + System.out.println(Cookie.toString(j)); + System.out.println(""); + + j=new JSONObject("{script: 'It is not allowed in HTML to send a close script tag in a stringso we insert a backslash before the /'}"); + System.out.println(j.toString()); + System.out.println(""); + + JSONTokener jt=new JSONTokener("{op:'test', to:'session', pre:1}{op:'test', to:'session', pre:2}"); + j=new JSONObject(jt); + System.out.println(j.toString()); + System.out.println("pre: " + j.optInt("pre")); + int i=jt.skipTo('{'); + System.out.println(i); + j=new JSONObject(jt); + System.out.println(j.toString()); + System.out.println(""); + + a=CDL.toJSONArray("Comma delimited list test, '\"Strip\"Quotes', 'quote, comma', No quotes, 'Single Quotes', \"Double Quotes\"\n1,'2',\"3\"\n,'It is \"good,\"', \"It works.\"\n\n"); + + s=CDL.toString(a); + System.out.println(s); + System.out.println(""); + System.out.println(a.toString(4)); + System.out.println(""); + a=CDL.toJSONArray(s); + System.out.println(a.toString(4)); + System.out.println(""); + + a=new JSONArray(" [\"\", next is an implied null , , ok,] "); + System.out.println(a.toString()); + System.out.println(""); + System.out.println(XML.toString(a)); + System.out.println(""); + + j=new JSONObject("{ fun => with non-standard forms ; forgiving => This package can be used to parse formats that are similar to but not stricting ocforming to JSON; why=To make it easier to migrate existing data to JSON,one=[[1.00]]; uno=[[{1=>1}]];'+':+6e66 ;pluses=+++;empty='' , 'double':0.666,true: TRUE, false: FALSE, null=NULL;[true]=[[!,@;*]]; string=> o. k. ; \r oct=0666; hex=0x666; dec=666; o=0999; noh=0x0x}"); + System.out.println(j.toString(4)); + System.out.println(""); + if (j.getBoolean("true") && !j.getBoolean("false")) { + System.out.println("It's all good"); + } + + System.out.println(""); + j=new JSONObject(j, new String[]{"dec", "oct", "hex", "missing"}); + System.out.println(j.toString(4)); + + System.out.println(""); + System.out.println(new JSONStringer().array().value(a).value(j).endArray()); + + j=new JSONObject("{string: \"98.6\", long: 2147483648, int: 2147483647, longer: 9223372036854775807, double: 9223372036854775808}"); + System.out.println(j.toString(4)); + + System.out.println("\ngetInt"); + System.out.println("int " + j.getInt("int")); + System.out.println("long " + j.getInt("long")); + System.out.println("longer " + j.getInt("longer")); + //System.out.println("double " + j.getInt("double")); + //System.out.println("string " + j.getInt("string")); + + System.out.println("\ngetLong"); + System.out.println("int " + j.getLong("int")); + System.out.println("long " + j.getLong("long")); + System.out.println("longer " + j.getLong("longer")); + //System.out.println("double " + j.getLong("double")); + //System.out.println("string " + j.getLong("string")); + + System.out.println("\ngetDouble"); + System.out.println("int " + j.getDouble("int")); + System.out.println("long " + j.getDouble("long")); + System.out.println("longer " + j.getDouble("longer")); + System.out.println("double " + j.getDouble("double")); + System.out.println("string " + j.getDouble("string")); + + j.put("good sized", 9223372036854775807L); + System.out.println(j.toString(4)); + + a=new JSONArray("[2147483647, 2147483648, 9223372036854775807, 9223372036854775808]"); + System.out.println(a.toString(4)); + + System.out.println("\nKeys: "); + it=j.keys(); + while (it.hasNext()) { + s=(String)it.next(); + System.out.println(s + ": " + j.getString(s)); + } + + + System.out.println("\naccumulate: "); + j=new JSONObject(); + j.accumulate("stooge", "Curly"); + j.accumulate("stooge", "Larry"); + j.accumulate("stooge", "Moe"); + a=j.getJSONArray("stooge"); + a.put(5, "Shemp"); + System.out.println(j.toString(4)); + + System.out.println("\nwrite:"); + System.out.println(j.write(new StringWriter())); + + s="122333"; + j=XML.toJSONObject(s); + System.out.println(j.toString(4)); + System.out.println(XML.toString(j)); + + s="Content of the first chapterContent of the seocd chapter Content of the first subchapter Content of the seocd subchapterThird Chapter"; + j=XML.toJSONObject(s); + System.out.println(j.toString(4)); + System.out.println(XML.toString(j)); + + a=JSONML.toJSONArray(s); + System.out.println(a.toString(4)); + System.out.println(JSONML.toString(a)); + + Collection c=null; + Map m=null; + + j=new JSONObject(m); + a=new JSONArray(c); + j.append("stooge", "Joe DeRita"); + j.append("stooge", "Shemp"); + j.accumulate("stooges", "Curly"); + j.accumulate("stooges", "Larry"); + j.accumulate("stooges", "Moe"); + j.accumulate("stoogearray", j.get("stooges")); + j.put("map", m); + j.put("collection", c); + j.put("array", a); + a.put(m); + a.put(c); + System.out.println(j.toString(4)); + + s="{plist=Apple; AnimalSmells={ pig=piggish; lamb=lambish; worm=wormy; }; AnimalSounds={ pig=oink; lamb=baa; worm=baa; Lisa=\"Why is the worm talking like a lamb?\" } ; AnimalColors={ pig=pink; lamb=black; worm=pink; } } "; + j=new JSONObject(s); + System.out.println(j.toString(4)); + + s=" (\"San Francisco\", \"New York\", \"Seoul\", \"London\", \"Seattle\", \"Shanghai\")"; + a=new JSONArray(s); + System.out.println(a.toString()); + + s="The content of b and The content of cdoremi"; + j=XML.toJSONObject(s); + + System.out.println(j.toString(2)); + System.out.println(XML.toString(j)); + System.out.println(""); + ja=JSONML.toJSONArray(s); + System.out.println(ja.toString(4)); + System.out.println(JSONML.toString(ja)); + System.out.println(""); + + s="111111111111111"; + j=JSONML.toJSONObject(s); + System.out.println(j); + ja=JSONML.toJSONArray(s); + System.out.println(ja); + + + System.out.println("\nTesting Exceptions: "); + + System.out.print("Exception: "); + try { + a=new JSONArray("[\n\r\n\r}"); + System.out.println(a.toString()); + } catch (Exception e) { + System.out.println(e); + } + + System.out.print("Exception: "); + try { + a=new JSONArray("<\n\r\n\r "); + System.out.println(a.toString()); + } catch (Exception e) { + System.out.println(e); + } + + System.out.print("Exception: "); + try { + a=new JSONArray(); + a.put(Double.NEGATIVE_INFINITY); + a.put(Double.NaN); + System.out.println(a.toString()); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + System.out.println(j.getDouble("stooge")); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + System.out.println(j.getDouble("howard")); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + System.out.println(j.put(null, "howard")); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + System.out.println(a.getDouble(0)); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + System.out.println(a.get(-1)); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + System.out.println(a.put(Double.NaN)); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + j=XML.toJSONObject(" "); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + j=XML.toJSONObject(" "); + } catch (Exception e) { + System.out.println(e); + } + System.out.print("Exception: "); + try { + j=XML.toJSONObject("'. */ + public static final Character GT =Character.valueOf('>'); + + /** The Character '<'. */ + public static final Character LT =Character.valueOf('<'); + + /** The Character '?'. */ + public static final Character QUEST=Character.valueOf('?'); + + /** The Character '"'. */ + public static final Character QUOT =Character.valueOf('"'); + + /** The Character '/'. */ + public static final Character SLASH=Character.valueOf('/'); + + /** + * Replace special characters with XML escapes: + * 
+     * & (ampersand) is replaced by &amp;
+     * < (less than) is replaced by &lt;
+     * > (greater than) is replaced by &gt;
+     * " (double quote) is replaced by &quot;
+     *
+ * @param string The string to be escaped. + * @return The escaped string. + */ + public static String escape(String string) { + StringBuffer sb=new StringBuffer(); + for (int i=0, len=string.length(); i < len; i++) { + char c=string.charAt(i); + switch (c) { + case '&': + sb.append("&"); + break; + case '<': + sb.append("<"); + break; + case '>': + sb.append(">"); + break; + case '"': + sb.append("""); + break; + default: + sb.append(c); + } + } + return sb.toString(); + } + + /** + * Throw an exception if the string contains whitespace. + * Whitespace is not allowed in tagNames and attributes. + * @param string + * @throws JSONException + */ + public static void noSpace(String string) throws JSONException { + int i, length=string.length(); + if (length == 0) { + throw new JSONException("Empty string."); + } + for (i=0; i < length; i += 1) { + if (Character.isWhitespace(string.charAt(i))) { + throw new JSONException("'" + string + + "' contains a space character."); + } + } + } + + /** + * Scan the content following the named tag, attaching it to the octext. + * @param x The XMLTokener octaining the source string. + * @param octext The JSONObject that will include the new material. + * @param name The tag name. + * @return true if the close tag is processed. + * @throws JSONException + */ + private static boolean parse(XMLTokener x, JSONObject octext, + String name) throws JSONException { + char c; + int i; + String n; + JSONObject o=null; + String s; + Object t; + +// Test for and skip past these forms: +// +// +// +// +// Report errors for these forms: +// <> +// <= +// << + + t=x.nextToken(); + +// "); + return false; + } + x.back(); + } else if (c == '[') { + t=x.nextToken(); + if (t.equals("CDATA")) { + if (x.next() == '[') { + s=x.nextCDATA(); + if (s.length() > 0) { + octext.accumulate("content", s); + } + return false; + } + } + throw x.syntaxError("Expected 'CDATA['"); + } + i=1; + do { + t=x.nextMeta(); + if (t == null) { + throw x.syntaxError("Missing '>' after ' 0); + return false; + } else if (t == QUEST) { + +// "); + return false; + } else if (t == SLASH) { + +// Close tag + + } else if (t == SLASH) { + if (x.nextToken() != GT) { + throw x.syntaxError("Misshaped tag"); + } + if (o.length() > 0) { + octext.accumulate(n, o); + } else { + octext.accumulate(n, ""); + } + return false; + +// Content, between <...> and + + } else if (t == GT) { + for (;;) { + t=x.nextContent(); + if (t == null) { + if (n != null) { + throw x.syntaxError("Unclosed tag " + n); + } + return false; + } else if (t instanceof String) { + s=(String)t; + if (s.length() > 0) { + o.accumulate("content", JSONObject.stringToValue(s)); + } + +// Nested element + + } else if (t == LT) { + if (parse(x, o, n)) { + if (o.length() == 0) { + octext.accumulate(n, ""); + } else if (o.length() == 1 && + o.opt("content") != null) { + octext.accumulate(n, o.opt("content")); + } else { + octext.accumulate(n, o); + } + return false; + } + } + } + } else { + throw x.syntaxError("Misshaped tag"); + } + } + } + } + + + /** + * Convert a well-formed (but not necessarily valid) XML string into a + * JSONObject. Some information may be lost in this transformation + * because JSON is a data format and XML is a document format. XML uses + * elements, attributes, and content text, while JSON uses unordered + * collections of name/value pairs and arrays of values. JSON does not + * does not like to distinguish between elements and attributes. + * Sequences of similar elements are represented as JSONArrays. Content + * text may be placed in a "content" member. Comments, prologs, DTDs, and + * <[ [ ]]> are ignored. + * @param string The source string. + * @return A JSONObject octaining the structured data from the XML string. + * @throws JSONException + */ + public static JSONObject toJSONObject(String string) throws JSONException { + JSONObject o=new JSONObject(); + XMLTokener x=new XMLTokener(string); + while (x.more() && x.skipPast("<")) { + parse(x, o, null); + } + return o; + } + + + /** + * Convert a JSONObject into a well-formed, element-normal XML string. + * @param o A JSONObject. + * @return A string. + * @throws JSONException + */ + public static String toString(Object o) throws JSONException { + return toString(o, null); + } + + + /** + * Convert a JSONObject into a well-formed, element-normal XML string. + * @param o A JSONObject. + * @param tagName The optional name of the enclosing tag. + * @return A string. + * @throws JSONException + */ + public static String toString(Object o, String tagName) + throws JSONException { + StringBuffer b=new StringBuffer(); + int i; + JSONArray ja; + JSONObject jo; + String k; + Iterator keys; + int len; + String s; + Object v; + if (o instanceof JSONObject) { + +// Emit + + if (tagName != null) { + b.append('<'); + b.append(tagName); + b.append('>'); + } + +// Loop thru the keys. + + jo=(JSONObject)o; + keys=jo.keys(); + while (keys.hasNext()) { + k=keys.next().toString(); + v=jo.opt(k); + if (v == null) { + v=""; + } + if (v instanceof String) { + s=(String)v; + } else { + s=null; + } + +// Emit content in body + + if (k.equals("content")) { + if (v instanceof JSONArray) { + ja=(JSONArray)v; + len=ja.length(); + for (i=0; i < len; i += 1) { + if (i > 0) { + b.append('\n'); + } + b.append(escape(ja.get(i).toString())); + } + } else { + b.append(escape(v.toString())); + } + +// Emit an array of similar keys + + } else if (v instanceof JSONArray) { + ja=(JSONArray)v; + len=ja.length(); + for (i=0; i < len; i += 1) { + v=ja.get(i); + if (v instanceof JSONArray) { + b.append('<'); + b.append(k); + b.append('>'); + b.append(toString(v)); + b.append("'); + } else { + b.append(toString(v, k)); + } + } + } else if (v.equals("")) { + b.append('<'); + b.append(k); + b.append("/>"); + +// Emit a new tag + + } else { + b.append(toString(v, k)); + } + } + if (tagName != null) { + +// Emit the close tag + + b.append("'); + } + return b.toString(); + +// XML does not have good support for arrays. If an array appears in a place +// where XML is lacking, synthesize an element. + + } else if (o instanceof JSONArray) { + ja=(JSONArray)o; + len=ja.length(); + for (i=0; i < len; ++i) { + v=ja.opt(i); + b.append(toString(v, (tagName == null) ? "array" : tagName)); + } + return b.toString(); + } else { + s=(o == null) ? "null" : escape(o.toString()); + return (tagName == null) ? "\"" + s + "\"" : + (s.length() == 0) ? "<" + tagName + "/>" : + "<" + tagName + ">" + s + ""; + } + } +} \ No newline at end of file diff --git a/src/main/java/systems/sdw/basetech/json/XMLTokener.java b/src/main/java/systems/sdw/basetech/json/XMLTokener.java new file mode 100644 index 0000000..a99b822 --- /dev/null +++ b/src/main/java/systems/sdw/basetech/json/XMLTokener.java @@ -0,0 +1,365 @@ +package systems.sdw.basetech.json; + +/* +Copyright (c) 2002 JSON.org + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following ocditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +The Software shall be used for Good, not Evil. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +/** + * The XMLTokener extends the JSONTokener to provide additional methods + * for the parsing of XML texts. + * @author JSON.org + * @version 2010-01-30 + */ +public class XMLTokener extends JSONTokener { + + + /** The table of entity values. It initially contains Character values for + * amp, apos, gt, lt, quot. + */ + public static final java.util.HashMap entity; + + static { + entity=new java.util.HashMap(8); + entity.put("amp", XML.AMP); + entity.put("apos", XML.APOS); + entity.put("gt", XML.GT); + entity.put("lt", XML.LT); + entity.put("quot", XML.QUOT); + } + + /** + * Construct an XMLTokener from a string. + * @param s A source string. + */ + public XMLTokener(String s) { + super(s); + } + + /** + * Get the text in the CDATA block. + * @return The string up to the ]]>. + * @throws JSONException If the ]]> is not found. + */ + public String nextCDATA() throws JSONException { + char c; + int i; + StringBuffer sb=new StringBuffer(); + for (;;) { + c=next(); + if (end()) { + throw syntaxError("Unclosed CDATA"); + } + sb.append(c); + i=sb.length() - 3; + if (i >= 0 && sb.charAt(i) == ']' && + sb.charAt(i + 1) == ']' && sb.charAt(i + 2) == '>') { + sb.setLength(i); + return sb.toString(); + } + } + } + + + /** + * Get the next XML outer token, trimming whitespace. There are two kinds + * of tokens: the '<' character which begins a markup tag, and the content + * text between markup tags. + * + * @return A string, or a '<' Character, or null if there is no more + * source text. + * @throws JSONException + */ + public Object nextContent() throws JSONException { + char c; + StringBuffer sb; + do { + c=next(); + } while (Character.isWhitespace(c)); + if (c == 0) { + return null; + } + if (c == '<') { + return XML.LT; + } + sb=new StringBuffer(); + for (;;) { + if (c == '<' || c == 0) { + back(); + return sb.toString().trim(); + } + if (c == '&') { + sb.append(nextEntity(c)); + } else { + sb.append(c); + } + c=next(); + } + } + + + /** + * Return the next entity. These entities are translated to Characters: + * & ' > < ". + * @param a An ampersand character. + * @return A Character or an entity String if the entity is not recognized. + * @throws JSONException If missing ';' in XML entity. + */ + public Object nextEntity(char a) throws JSONException { + StringBuffer sb=new StringBuffer(); + for (;;) { + char c=next(); + if (Character.isLetterOrDigit(c) || c == '#') { + sb.append(Character.toLowerCase(c)); + } else if (c == ';') { + break; + } else { + throw syntaxError("Missing ';' in XML entity: &" + sb); + } + } + String s=sb.toString(); + Object e=entity.get(s); + return e != null ? e : a + s + ";"; + } + + + /** + * Returns the next XML meta token. This is used for skipping over + * and structures. + * @return Syntax characters (< > /=! ?) are returned as + * Character, and strings and names are returned as Boolean. We don't care + * what the values actually are. + * @throws JSONException If a string is not properly closed or if the XML + * is badly structured. + */ + public Object nextMeta() throws JSONException { + char c; + char q; + do { + c=next(); + } while (Character.isWhitespace(c)); + switch (c) { + case 0: + throw syntaxError("Misshaped meta tag"); + case '<': + return XML.LT; + case '>': + return XML.GT; + case '/': + return XML.SLASH; + case '=': + return XML.EQ; + case '!': + return XML.BANG; + case '?': + return XML.QUEST; + case '"': + case '\'': + q=c; + for (;;) { + c=next(); + if (c == 0) { + throw syntaxError("Unterminated string"); + } + if (c == q) { + return Boolean.TRUE; + } + } + default: + for (;;) { + c=next(); + if (Character.isWhitespace(c)) { + return Boolean.TRUE; + } + switch (c) { + case 0: + case '<': + case '>': + case '/': + case '=': + case '!': + case '?': + case '"': + case '\'': + back(); + return Boolean.TRUE; + } + } + } + } + + + /** + * Get the next XML Token. These tokens are found inside of angle + * brackets. It may be one of these characters: / >=! ? or it + * may be a string wrapped in single quotes or double quotes, or it may be a + * name. + * @return a String or a Character. + * @throws JSONException If the XML is not well formed. + */ + public Object nextToken() throws JSONException { + char c; + char q; + StringBuffer sb; + do { + c=next(); + } while (Character.isWhitespace(c)); + switch (c) { + case 0: + throw syntaxError("Misshaped element"); + case '<': + throw syntaxError("Misplaced '<'"); + case '>': + return XML.GT; + case '/': + return XML.SLASH; + case '=': + return XML.EQ; + case '!': + return XML.BANG; + case '?': + return XML.QUEST; + +// Quoted string + + case '"': + case '\'': + q=c; + sb=new StringBuffer(); + for (;;) { + c=next(); + if (c == 0) { + throw syntaxError("Unterminated string"); + } + if (c == q) { + return sb.toString(); + } + if (c == '&') { + sb.append(nextEntity(c)); + } else { + sb.append(c); + } + } + default: + +// Name + + sb=new StringBuffer(); + for (;;) { + sb.append(c); + c=next(); + if (Character.isWhitespace(c)) { + return sb.toString(); + } + switch (c) { + case 0: + return sb.toString(); + case '>': + case '/': + case '=': + case '!': + case '?': + case '[': + case ']': + back(); + return sb.toString(); + case '<': + case '"': + case '\'': + throw syntaxError("Bad character in a name"); + } + } + } + } + + + /** + * Skip characters until past the requested string. + * If it is not found, we are left at the end of the source with a result of false. + * @param to A string to skip past. + * @throws JSONException + */ + public boolean skipPast(String to) throws JSONException { + boolean b; + char c; + int i; + int j; + int offset=0; + int n=to.length(); + char[] circle=new char[n]; + + /* + * First fill the circle buffer with as many characters as are in the + * to string. If we reach an early end, bail. + */ + + for (i=0; i < n; i += 1) { + c=next(); + if (c == 0) { + return false; + } + circle[i]=c; + } + /* + * We will loop, possibly for all of the remaining characters. + */ + for (;;) { + j=offset; + b=true; + /* + * Compare the circle buffer with the to string. + */ + for (i=0; i < n; i += 1) { + if (circle[j] != to.charAt(i)) { + b=false; + break; + } + j += 1; + if (j >= n) { + j -= n; + } + } + /* + * If we exit the loop with b intact, then victory is ours. + */ + if (b) { + return true; + } + /* + * Get the next character. If there isn't one, then defeat is ours. + */ + c=next(); + if (c == 0) { + return false; + } + /* + * Shove the character in the circle buffer and advance the + * circle offset. The offset is mod n. + */ + circle[offset]=c; + offset += 1; + if (offset >= n) { + offset -= n; + } + } + } +} diff --git a/src/main/webapp/META-INF/MANIFEST.MF b/src/main/webapp/META-INF/MANIFEST.MF new file mode 100644 index 0000000..5e94951 --- /dev/null +++ b/src/main/webapp/META-INF/MANIFEST.MF @@ -0,0 +1,3 @@ +Manifest-Version: 1.0 +Class-Path: + diff --git a/src/main/webapp/WEB-INF/lib/library-2.13.0-shaded.jar b/src/main/webapp/WEB-INF/lib/library-2.13.0-shaded.jar new file mode 100644 index 0000000..f36ea19 Binary files /dev/null and b/src/main/webapp/WEB-INF/lib/library-2.13.0-shaded.jar differ diff --git a/src/main/webapp/WEB-INF/web.xml b/src/main/webapp/WEB-INF/web.xml new file mode 100644 index 0000000..bd6aa52 --- /dev/null +++ b/src/main/webapp/WEB-INF/web.xml @@ -0,0 +1,49 @@ + + + + + ZFD + + + Frontcontroller + Frontcontroller + fc + systems.sdw.Frontcontroller + + + + fc + /fc + + + + 600 + + + + + Debug + system.debug + true + + + + Speicherort fuer temporaere Dateien, insb. Druckerzeugnisse + system.defaults.tmpPath + /tmp + + + + Wurzel der Speicherhierarchie des DMS + system.defaults.dmsPath + /data/dms + + + + index.jsp + + +