first commit

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.

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<Part> parts=request.getParts();
+		Iterator<Part> 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");
+	}
+
+}
+
+
+
+
+
+
+
+
+
+
+

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);
+		
+	}
+
+	
+	
+	
+	
+	
+
+}

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 <rsm:CrossIndustry which is the case for both 
+				 * ZF1 (CrossIndustryDocument) and ZF2 files (CrossIndustryInvoice).
+				 * Insert your (validated) XML here.
+				 */
+				System.out.println("Injecting ZUGFeRD-Data");
+				injectXML(ze, json);
+
+				System.out.println("Writing ZUGFeRD-PDF");
+				ze.export(pdf.getCanonicalPath());
+				ze.close();
+				
+				return appendZugferdDaten(pdf);
+
+			} catch (IOException | JSONException e) {
+				e.printStackTrace();
+			}
+		}
+		return null;
+	}
+
+
+	public static void injectXML(ZUGFeRDExporterFromA3 ze, JSONObject json) throws IOException, JSONException {
+
+		JSONObject sender=json.getJSONObject("sender");
+		JSONObject bankdetails=sender.getJSONObject("bankdetails");
+
+		JSONObject recipient=json.getJSONObject("recipient");
+		JSONObject contact=recipient.getJSONObject("contact");
+
+		//@SuppressWarnings("deprecation")
+		Invoice invoice=new Invoice()
+		.setDueDate(json.getAmericanDate("faelligkeitsdatum"))
+		.setIssueDate(json.getAmericanDate("rechnungsdatum"))
+		.setDeliveryDate(json.getAmericanDate("leistungsdatum"))
+
+		.setSender(new TradeParty(sender.getString("name"), sender.getString("strasse"), sender.getString("plz"), sender.getString("ort"), sender.getString("land"))
+				.addVATID(sender.getString("ustid"))
+				//	.addTaxID(sender.getString("steuernummer"))
+				.addBankDetails(new BankDetails(bankdetails.getString("iban"), bankdetails.getString("swift"))))    
+
+		.setRecipient(new TradeParty(recipient.getString("name"), recipient.getString("strasse"), recipient.getString("plz"), recipient.getString("ort"), recipient.getString("land"))
+				.setContact(new Contact(contact.getString("name"), contact.getString("telefon"), contact.getString("email")))).setNumber(json.getString("rechnungsnummer"));
+
+		JSONArray positionen=json.getJSONArray("positionen");
+		for (int i=0; i<=positionen.length()-1; i++) {
+			JSONObject position=positionen.getJSONObject(i);
+			JSONObject produkt=position.getJSONObject("produkt");
+
+//			System.out.println(i);
+//			System.out.println(position.toString(2));
+
+			
+			Item item=new Item(
+					new Product(produkt.getString("name"), produkt.getString("beschreibung", ""), produkt.getString("einheit"), new BigDecimal(produkt.getString("steuersatz"))),
+					new BigDecimal(position.getString("preis")), 
+					new BigDecimal(position.getString("menge")));
+
+			invoice.addItem(item);
+		}
+		ze.setTransaction(invoice);
+	}
+
+	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();
+	}
+
+
+	public static File appendZugferdDaten(File pdf) throws IOException  {
+		
+		ZUGFeRDImporter zi=new ZUGFeRDImporter(pdf.getCanonicalPath());
+
+		String[] zugferddata=new String[8];
+		zugferddata[0]="getInvoiceID " + zi.getInvoiceID();
+		zugferddata[1]="getInvoiceCurrencyCode " + zi.getInvoiceCurrencyCode();
+		zugferddata[2]="getDueDate " + zi.getDueDate();
+		zugferddata[3]="getIBAN " + zi.getIBAN();		
+		zugferddata[4]="getBIC " + zi.getBIC();	
+		zugferddata[5]="getLineTotalAmount " + zi.getLineTotalAmount();
+		zugferddata[6]="getTaxTotalAmount " + zi.getTaxTotalAmount();
+		zugferddata[7]="getAmount " + zi.getAmount();
+	
+		String profil="getZUGFeRDProfil "+zi.getZUGFeRDProfil();
+		String version="getVersion ?";
+		try {
+			version="getVersion "+String.valueOf(zi.getVersion());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		
+		System.out.println(zugferddata[0]);
+		System.out.println(zugferddata[1]);
+		System.out.println(zugferddata[2]);
+		System.out.println(zugferddata[3]);
+		System.out.println(zugferddata[4]);
+		System.out.println(zugferddata[5]);
+		System.out.println(zugferddata[6]);
+		System.out.println(zugferddata[7]);
+		System.out.println(profil);
+		System.out.println(version);
+	
+		
+		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, zugferddata[0]);
+		write(contentStream, 100,580, zugferddata[1]);
+		write(contentStream, 100,560, zugferddata[2]);
+		write(contentStream, 100,540, zugferddata[3]);
+		write(contentStream, 100,520, zugferddata[4]);
+		write(contentStream, 100,500, zugferddata[5]);
+		write(contentStream, 100,480, zugferddata[6]);
+		write(contentStream, 100,460, zugferddata[7]);
+
+		write(contentStream, 30,420, profil);
+		write(contentStream, 30,400, version);
+		
+		contentStream.close();
+
+		//	create target file in same directory.
+		//	do not use input file formoutput! 
+		File targetFile=new File(pdf.getParent()+"/"+UUID.randomUUID());
+		doc.save(targetFile);
+
+		doc.close();
+		
+		return targetFile;
+	}
+
+
+
+
+
+
+
+}

src/main/java/systems/sdw/baseapps/Protokoll.java

@@ -0,0 +1,399 @@
+package systems.sdw.baseapps;
+
+import java.sql.Timestamp;
+
+import javax.servlet.http.HttpServletRequest;
+
+import systems.sdw.basetech.json.JSONException;
+import systems.sdw.basetech.json.JSONObject;
+
+
+public class Protokoll {
+	
+	public final static String DRIVER_SAPDB="com.sap.dbtech.jdbc.DriverSapDB";
+	public final static String DRIVER_MAXDB="com.sap.dbtech.jdbc.DriverSapDB";
+	public final static String DRIVER_ORACLE="oracle.jdbc.driver.OracleDriver";
+	public final static String DRIVER_SQLSERVER="com.microsoft.sqlserver.jdbc.SQLServerDriver";
+	public final static String DRIVER_POSTGRESQL = "org.postgresql.Driver";
+	public final static String DRIVER_MSSQLJTDS = "net.sourceforge.jtds.jdbc.Driver";
+
+
+	private static final String jndiSDW="jdbc/SDW";
+	
+	public static final String jndiDefault=jndiSDW;
+
+	public static final String encodingUTF8="UTF-8";	
+	public static final String encodingISO="ISO-8859-1";
+	public static final String encodingDefault=encodingUTF8;
+	
+	public static final String OptionNotSet="notSet";
+
+	//	 Query
+	public static final String muster="muster";
+	public static final String stichtag="stichtag";
+
+	//	Frontcontroller
+	public static final String tmpDir="tmpdir";	
+	public static final String resourcePath="resourcepath";	
+	public static final String dmsDir="dmsdir";	
+	
+	public static final String barrierefrei="bf";
+	public static final String opcode="opc";
+	public static final String oid="oid";
+	public static final String cls="cls";
+	public static final String date="date";
+	public static final String data="data";
+	public static final String event="event";
+	public static final String xml="XML";
+	public static final String json="JSON";
+	public static final String jsonimage="jsonimage";
+	public static final String token="token";
+	public static final String action="action";
+	public static final String magic="magic";
+
+	public static final String name="name";
+	public static final String konfig="konfig";
+	public static final String modulename="modulename";
+	public static final String aktiv="aktiv";
+	public static final String uri="uri";
+	public static final String reihenfolge="reihenfolge";
+	public static final String uuid="uuid";
+	public static final String pass="pass";
+	public static final String zugriffsrecht="zugriffsrecht";
+	public static final String filename="filename";
+	
+	public static final String command="command";
+	public static final String params="params";
+	public static final String param="param";
+	public static final String value="value";
+	public static final String type="type";
+	public static final String default_="default";
+	public static final String typeNumber="number";
+	public static final String typeString="string";
+	
+	public static final String itemCount="itemCount";
+	public static final String resultSetCount="resultSetCount";
+	
+	public static final String attribut="attribut";
+	public static final String wert="wert";
+	public static final String titel="titel";
+	public static final String beschreibung="beschreibung";
+	public static final String exception="exception";
+
+	public static final String zeitraum="zeitraum";
+	public static final String von="von";
+	public static final String bis="bis";
+	public static final String dauer="dauer";
+	public static final String datum="datum";
+	public static final String unbegrenzt="unbegrenzt";
+	public static final String allDay="allDay";
+
+	public static final String filter="filter";
+
+	public static final String html="html";
+	public static final String result="result";
+
+	public static final String identifier="identifier";
+	public static final String label="label";
+	public static final String field="field";
+	public static final String timestamp="timestamp";
+	public static final String linkLabel="linkLabel";
+
+	public static final String memo="memo";
+	public static final String memoNeu="memoneu";
+	public static final String memoAlt="memoalt";
+
+	public static final String id="id";
+	public static final String desc="desc";	
+	public static final String qualifiedName="qualifiedname";
+	public static final String schluessel="schluessel";
+	public static final String nummer="nummer";
+	public static final String positionen="positionen";
+	public static final String items="items";
+	public static final String itemsEingeklappt="_items_";
+	public static final String queryresult="queryresult";
+	public static final String item="item";
+	public static final String invers="invers";
+	public static final String itemlist="itemlist";
+	public static final String sortierung="sortierung";
+	
+	public static final String referenzobjekt="referenzobjekt";
+	
+	public static final String summe="summe";
+	public static final String summeEinnahmen="summe_einnahmen";
+	public static final String summeHonorar="summe_honorar";
+
+	
+	public static final String status="status";
+	public static final String info="info";
+	public static final String verfuegbarkeit="verfuegbarkeit";
+
+	public static final String sessionpersonal="systems_sdw_sessionpersonal";
+	
+	public static final String geodata="systems_sdw_Geodata";
+	
+	public static final String hasChildren="hasChildren";
+	public static final String children="children";
+	public static final String reference="_reference";
+	public static final String level="level";
+	public static final String kurzname="kurzname";
+	public static final String systematik="systematik";
+	public static final String flag="flag";
+	public static final String checked="checked";
+	public static final String menue="menue";
+	public static final String cssKlasse="cssklasse";
+	public static final String klasse="klasse";
+	
+	public static final String relation="relation";
+	
+	public static final String locale="locale";
+	public static final String chart="chart";
+	public static final String container="container";
+
+	public static final String text="text";
+	public static final String owner="owner";
+	public static final String dirtyFlag="_dirty_";
+	public static final String deleteFlag="_deleted_";
+	public static final String insertFlag="_inserted_";
+	public static final String updateFlag="_updated_";
+	public static final String tooltip="tooltip";
+	public static final String calendar="calendar";
+	public static final String ok="ok";
+	public static final String geo="geo";
+	
+	public static final String before="before";
+	public static final String after="after";
+	
+	//	Vereinheitlichung der Information, ob optionlists und so  das default-Objekt aus sys_defaultsobjects enthalten soll oder nicht
+	public static final String defaultObjects="defaultObjects";
+	
+	
+	
+	public static final String datentyp="datentyp";
+	public static final String datentypspalte="datentypspalte";
+
+	public static final String alphabetSelektor="alphabetselektor";
+	public static final String yearSelektor="yearselektor";
+	
+	
+	public static final String contenttypeForm="application/x-www-form-urlencoded";
+	public static final String contenttypeMmultipart="multipart/form-data";
+	public static final String contenttypeOctetStream="application/octet-stream";
+	
+	public static final String MIMETYPE_PDF = "application/pdf";
+	public static final String MIMETYPE_XML = "text/xml";
+	public static final String MIMETYPE_TXT = "text/plain";
+	public static final String MIMETYPE_HTML = "text/html";	
+	public static final String MIMETYPE_GIF = "image/gif";
+	public static final String MIMETYPE_JPG = "image/jpeg";
+	public static final String MIMETYPE_PNG = "image/png";
+	public static final String MIMETYPE_WORD = "application/msword";
+	public static final String MIMETYPE_POWERPOINT = "application/mspowerpoint";
+	public static final String MIMETYPE_EXCEL = "application/msexcel";
+	public static final String MIMETYPE_PS = "application/postscript";
+	
+	public static final String response="response";
+	
+	public static final String sessionNutzer="nutzer";
+	public static final String sessionNutzerSession="nutzersession";
+	public static final String session_organisation="organisation";
+
+	public static final String sERROR_404_PDF="404_FileNotFound.pdf";
+	public static final String cOPEN_WINDOW_PARAMLISTE="menubar=yes,dependent=yes,status=yes,resizable=yes,scrollbars=yes,Width=800,Height=600,Screenx=25,Screeny=25";
+
+	public static final String beschreibungDefault="Zeitstempel:"+getTimestamp();
+	public static final String beschreibungAuto="n/a";
+	
+	
+	public static final String rangeKlasseDate="iso_date_range";
+	public static final String rangeKlasseTimestamp="iso_timestamp_range";
+	public static final String rangeKlasseTime="iso_time_range";
+
+	
+	public static final String loremIpsum="Weit hinten, hinter den Wortbergen, fern der Länder Vokalien und Konsonantien leben die Blindtexte. Abgeschieden wohnen sie in Buchstabhausen an der Küste des Semantik, eines großen Sprachozeans. Ein kleines Bächlein namens Duden fließt durch ihren Ort und versorgt sie mit den nötigen Regelialien. Es ist ein paradiesmatisches Land, in dem einem gebratene Satzteile in den Mund fliegen.";
+	public static final String readOnly = "readOnly";
+	
+	public static final String gesperrtStatus = "gesperrtStatus";
+	public static final String archivStatus = "archivStatus";
+
+	// REST - Style
+	public static final String jsonResponseStyle = "responsStyle";
+	public static final String hostPart = "hostPart";
+	public static final String styleREST = "rest";
+	public static final String styleClassic = "classic";
+	public static final String restUrl = "url";
+
+
+	public static final String authInfo = "authInfo";
+	public static final String roleInfo = "roleInfo";
+
+	public static final String gridLabel = "_gridLabel";
+	
+	
+	/**
+	 * Quick and dirty, sollte aber für die einfachen Tags in den Labeln reichen
+	 * @param input
+	 * @return
+	 */
+	public static String stripHTMLTags(String input) {
+		return input.replaceAll("<[^>]*>", "");
+	}
+
+	
+	/**
+	 * 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;}
+	}
+	
+	
+
+
+}

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.
+ * <p>
+ * 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.
+ * <p>
+ * The first row usually contains the names of the columns.
+ * <p>
+ * 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();
+    }
+}

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 <code>%</code><i>hh</i> sequences to single characters, and
+     * ocvert plus to space.
+     * @param s A string that may octain
+     *      <code>+</code>&nbsp;<small>(plus)</small> and
+     *      <code>%</code><i>hh</i> 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();
+    }
+}

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();
+    }
+}

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
+     * <pre>{
+     *    Method: "POST" (for example),
+     *    "Request-URI": "/" (for example),
+     *    "HTTP-Version": "HTTP/1.1" (for example)
+     * }</pre>
+     * A response header will octain
+     * <pre>{
+     *    "HTTP-Version": "HTTP/1.1" (for example),
+     *    "Status-Code": "200" (for example),
+     *    "Reason-Phrase": "OK" (for example)
+     * }</pre>
+     * In addition, the other parameters in the header will be captured, using
+     * the HTTP field names as JSON names, so that <pre>
+     *    Date: Sun, 26 May 2002 18:06:04 GMT
+     *    Cookie: Q=q2=PPEAsg--; B=677gi6ouf29bn&b=2&f=s
+     *    Cache-Control: no-cache</pre>
+     * become
+     * <pre>{...
+     *    Date: "Sun, 26 May 2002 18:06:04 GMT",
+     *    Cookie: "Q=q2=PPEAsg--; B=677gi6ouf29bn&b=2&f=s",
+     *    "Cache-Control": "no-cache",
+     * ...}</pre>
+     * 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
+     * <pre>{
+     *    Method: "POST" (for example),
+     *    "Request-URI": "/" (for example),
+     *    "HTTP-Version": "HTTP/1.1" (for example)
+     * }</pre>
+     * A response header must octain
+     * <pre>{
+     *    "HTTP-Version": "HTTP/1.1" (for example),
+     *    "Status-Code": "200" (for example),
+     *    "Reason-Phrase": "OK" (for example)
+     * }</pre>
+     * 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();
+    }
+}

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();
+        }
+    }
+}

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;
+	}
+}

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 </
+
+			        	token=x.nextToken();
+			        	if (!(token instanceof String)) {
+			        		throw new JSONException(
+			        				"Expected a closing name instead of '" + 
+			        				token + "'.");
+			        	}
+			            if (x.nextToken() != XML.GT) {
+			                throw x.syntaxError("Misshaped close tag");
+			            }
+			            return token;
+			        } else if (token == XML.BANG) {
+        		
+// <!
+        	
+			            c=x.next();
+			            if (c == '-') {
+			                if (x.next() == '-') {
+			                    x.skipPast("-->");
+			                }
+			                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 '<!'.");
+				                } else if (token == XML.LT) {
+				                    i += 1;
+				                } else if (token == XML.GT) {
+				                    i -= 1;
+				                }
+				            } while (i > 0);
+			            }
+			        } else if (token == XML.QUEST) {
+
+// <?
+
+			        	x.skipPast("?>");
+			        } 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 <code>&lt;[ [ ]]></code> 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 <code>&lt;[ [ ]]></code> 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 <code>&lt;[ [ ]]></code> 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 <code>&lt;[ [ ]]></code> 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 <tagName	    
+    	
+    	tagName=ja.getString(0);
+		XML.noSpace(tagName);
+		tagName=XML.escape(tagName);
+		sb.append('<');
+		sb.append(tagName);
+		
+		e=ja.opt(1);
+		if (e instanceof JSONObject) {
+			i=2;
+			jo=(JSONObject)e;
+			
+// Emit the attributes
+			
+	        keys=jo.keys();
+	        while (keys.hasNext()) {
+	            k=keys.next().toString();
+            	XML.noSpace(k);
+	            v=jo.optString(k);
+	            if (v != null) {
+		            sb.append(' ');
+		            sb.append(XML.escape(k));
+		            sb.append('=');
+		            sb.append('"');
+		            sb.append(XML.escape(v));
+		            sb.append('"');
+	            }
+	        }  
+		} else {
+			i=1;
+		}
+	     	
+//Emit content in body
+	    	
+		length=ja.length();
+		if (i >= 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 <tagName
+	
+		tagName=jo.optString("tagName");
+		if (tagName == null) {
+			return XML.escape(jo.toString());
+		}
+		XML.noSpace(tagName);
+		tagName=XML.escape(tagName);
+		sb.append('<');
+		sb.append(tagName);
+	
+//Emit the attributes
+	
+        keys=jo.keys();
+        while (keys.hasNext()) {
+            k=keys.next().toString();
+            if (!k.equals("tagName") && !k.equals("childNodes")) {
+            	XML.noSpace(k);
+	            v=jo.optString(k);
+	            if (v != null) {
+		            sb.append(' ');
+		            sb.append(XML.escape(k));
+		            sb.append('=');
+		            sb.append('"');
+		            sb.append(XML.escape(v));
+		            sb.append('"');
+	            }
+            }
+        }    
+		     	
+//Emit content in body
+	
+		ja=jo.optJSONArray("childNodes");
+		if (ja == null) {
+	        sb.append('/');
+	        sb.append('>');
+		} 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();
+    }
+}

src/main/java/systems/sdw/basetech/json/JSONString.java

@@ -0,0 +1,18 @@
+package systems.sdw.basetech.json;
+/**
+ * The <code>JSONString</code> interface allows a <code>toJSONString()</code> 
+ * method so that a class can change the behavior of 
+ * <code>JSONObject.toString()</code>, <code>JSONArray.toString()</code>,
+ * and <code>JSONWriter.value(</code>Object<code>)</code>. The 
+ * <code>toJSONString</code> method will be used instead of the default behavior 
+ * of using the Object's <code>toString()</code> method and quoting the result.
+ */
+public interface JSONString {
+	/**
+	 * The <code>toJSONString</code> method allows a class to produce its own JSON 
+	 * serialization. 
+	 * 
+	 * @return A strictly syntactically correct JSON text.
+	 */
+	public String toJSONString();
+}

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.
+ * <p>
+ * A JSONStringer instance provides a <code>value</code> method for appending
+ * values to the
+ * text, and a <code>key</code>
+ * method for adding keys before values in objects. There are <code>array</code>
+ * and <code>endArray</code> methods that make and bound array values, and
+ * <code>object</code> and <code>endObject</code> methods which make and bound
+ * object values. All of these methods return the JSONWriter instance,
+ * permitting cascade style. For example, <pre>
+ * myString=new JSONStringer()
+ *     .object()
+ *         .key("JSON")
+ *         .value("Hello, World!")
+ *     .endObject()
+ *     .toString();</pre> which produces the string <pre>
+ * {"JSON":"Hello, World!"}</pre>
+ * <p>
+ * The first method called must be <code>array</code> or <code>object</code>.
+ * 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.
+ * <p>
+ * 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 <code>null</code> if there was a
+     * problem in the ocstruction of the JSON text (such as the calls to
+     * <code>array</code> were not properly balanced with calls to
+     * <code>endArray</code>).
+     * @return The JSON text.
+     */
+    public String toString() {
+        return this.mode == 'd' ? this.writer.toString() : null;
+    }
+}

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
+     *      <code>"</code>&nbsp;<small>(double quote)</small> or
+     *      <code>'</code>&nbsp;<small>(single quote)</small>.
+     * @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 + "]";
+    }
+}

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.
+ * <p>
+ * A JSONWriter instance provides a <code>value</code> method for appending
+ * values to the
+ * text, and a <code>key</code>
+ * method for adding keys before values in objects. There are <code>array</code>
+ * and <code>endArray</code> methods that make and bound array values, and
+ * <code>object</code> and <code>endObject</code> methods which make and bound
+ * object values. All of these methods return the JSONWriter instance,
+ * permitting a cascade style. For example, <pre>
+ * new JSONWriter(myWriter)
+ *     .object()
+ *         .key("JSON")
+ *         .value("Hello, World!")
+ *     .endObject();</pre> which writes <pre>
+ * {"JSON":"Hello, World!"}</pre>
+ * <p>
+ * The first method called must be <code>array</code> or <code>object</code>.
+ * 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.
+ * <p>
+ * 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
+     * <code>endArray</code> will be appended to this array. The
+     * <code>endArray</code> 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
+     * <code>array</code>.
+     * @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
+     * <code>object</code>.
+     * @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
+     * <code>endObject</code> will be appended to this object. The
+     * <code>endObject</code> 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 <code>true</code> or the value
+     * <code>false</code>.
+     * @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));
+    }
+}

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("<![CDATA[This is a collection of test patterns and examples for org.json.]]>  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="<test><blank></blank><empty/></test>";
+            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="<recipe name=\"bread\" prep_time=\"5 mins\" cook_time=\"3 hours\"> <title>Basic bread</title> <ingredient amount=\"8\" unit=\"dL\">Flour</ingredient> <ingredient amount=\"10\" unit=\"grams\">Yeast</ingredient> <ingredient amount=\"4\" unit=\"dL\" state=\"warm\">Water</ingredient> <ingredient amount=\"1\" unit=\"teaspoon\">Salt</ingredient> <instructions> <step>Mix all ingredients together.</step> <step>Knead thoroughly.</step> <step>Cover with a cloth, and leave for one hour in warm room.</step> <step>Knead again.</step> <step>Place in a bread baking tin.</step> <step>Cover with a cloth, and leave for one hour in warm room.</step> <step>Bake in the oven at 180(degrees)C for 30 minutes.</step> </instructions> </recipe> ";
+            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="<div id=\"demo\" class=\"JSONML\"><p>JSONML is a transformation between <b>JSON</b> and <b>XML</b> that preserves ordering of document features.</p><p>JSONML can work with JSON arrays or JSON objects.</p><p>Three<br/>little<br/>words</p></div>";
+            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="<person created=\"2006-11-11T19:23\" modified=\"2006-12-31T23:59\">\n <firstName>Robert</firstName>\n <lastName>Smith</lastName>\n <address type=\"home\">\n <street>12345 Sixth Ave</street>\n <city>Anytown</city>\n <state>CA</state>\n <postalCode>98765-4321</postalCode>\n </address>\n </person>";
+            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: '</script>', 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 <fine>.");
+            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="<xml one=1 two=' \"2\" '><five></five>First \u0009&lt;content&gt;<five></five> This is \"content\". <three>  3  </three>JSON does not preserve the sequencing of elements and contents.<three>  III  </three>  <three>  T H R E E</three><four/>Content text is an implied structure in XML. <six content=\"6\"/>JSON does not have implied structure:<seven>7</seven>everything is explicit.<![CDATA[CDATA blocks<are><supported>!]]></xml>";
+            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="<xml do='0'>uno<a re='1' mi='2'>dos<b fa='3'/>tres<c>true</c>quatro</a>cinqo<d>seis<e/></d></xml>";
+            ja=JSONML.toJSONArray(s);
+            System.out.println(ja.toString(4));
+            System.out.println(JSONML.toString(ja));
+            System.out.println("");
+
+            s="<mapping><empty/>   <class name=\"Customer\">      <field name=\"ID\" type=\"string\">         <bind-xml name=\"ID\" node=\"attribute\"/>      </field>      <field name=\"FirstName\" type=\"FirstName\"/>      <field name=\"MI\" type=\"MI\"/>      <field name=\"LastName\" type=\"LastName\"/>   </class>   <class name=\"FirstName\">      <field name=\"text\">         <bind-xml name=\"text\" node=\"text\"/>      </field>   </class>   <class name=\"MI\">      <field name=\"text\">         <bind-xml name=\"text\" node=\"text\"/>      </field>   </class>   <class name=\"LastName\">      <field name=\"text\">         <bind-xml name=\"text\" node=\"text\"/>      </field>   </class></mapping>";
+            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("<?xml version=\"1.0\" ?><Book Author=\"Anonymous\"><Title>Sample Book</Title><Chapter id=\"1\">This is chapter 1. It is not very long or interesting.</Chapter><Chapter id=\"2\">This is chapter 2. Although it is longer than chapter 1, it is not any more interesting.</Chapter></Book>");
+            System.out.println(j.toString(2));
+            System.out.println(XML.toString(j));
+            System.out.println("");
+
+            j=XML.toJSONObject("<!DOCTYPE bCard 'http://www.cs.caltech.edu/~adam/schemas/bCard'><bCard><?xml default bCard        firstname=''        lastname ='' company  ='' email='' homepage =''?><bCard        firstname='Rohit'        lastname ='Khare'        company  ='MCI'        email    ='khare@mci.net'        homepage ='http://pest.w3.org/'/><bCard        firstname='Adam'        lastname ='Rifkin'        company  ='Caltech Infospheres Project'        email    ='adam@cs.caltech.edu'        homepage ='http://www.cs.caltech.edu/~adam/'/></bCard>");
+            System.out.println(j.toString(2));
+            System.out.println(XML.toString(j));
+            System.out.println("");
+
+            j=XML.toJSONObject("<?xml version=\"1.0\"?><customer>    <firstName>        <text>Fred</text>    </firstName>    <ID>fbs0001</ID>    <lastName> <text>Scerbo</text>    </lastName>    <MI>        <text>B</text>    </MI></customer>");
+            System.out.println(j.toString(2));
+            System.out.println(XML.toString(j));
+            System.out.println("");
+
+            j=XML.toJSONObject("<!ENTITY tp-address PUBLIC '-//ABC University::Special Collections Library//TEXT (titlepage: name and address)//EN' 'tpspcoll.sgm'><list type='simple'><head>Repository Address </head><item>Special Collections Library</item><item>ABC University</item><item>Main Library, 40 Circle Drive</item><item>Ourtown, Pennsylvania</item><item>17654 USA</item></list>");
+            System.out.println(j.toString());
+            System.out.println(XML.toString(j));
+            System.out.println("");
+
+            j=XML.toJSONObject("<test intertag status=ok><empty/>deluxe<blip sweet=true>&amp;&quot;toot&quot;&toot;&#x41;</blip><x>eks</x><w>bonus</w><w>bonus2</w></test>");
+            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("<?xml version='1.0' encoding='UTF-8'?>"+"\n\n"+"<SOAP-ENV:Envelope"+
+              " xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\""+
+              " xmlns:xsi=\"http://www.w3.org/1999/XMLSchema-instance\""+
+              " xmlns:xsd=\"http://www.w3.org/1999/XMLSchema\">"+
+              "<SOAP-ENV:Body><ns1:doGoogleSearch"+
+              " xmlns:ns1=\"urn:GoogleSearch\""+
+              " SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"+
+              "<key xsi:type=\"xsd:string\">GOOGLEKEY</key> <q"+
+              " xsi:type=\"xsd:string\">'+search+'</q> <start"+
+              " xsi:type=\"xsd:int\">0</start> <maxResults"+
+              " xsi:type=\"xsd:int\">10</maxResults> <filter"+
+              " xsi:type=\"xsd:boolean\">true</filter> <restrict"+
+              " xsi:type=\"xsd:string\"></restrict> <safeSearch"+
+              " xsi:type=\"xsd:boolean\">false</safeSearch> <lr"+
+              " xsi:type=\"xsd:string\"></lr> <ie"+
+              " xsi:type=\"xsd:string\">latin1</ie> <oe"+
+              " xsi:type=\"xsd:string\">latin1</oe>"+
+              "</ns1:doGoogleSearch>"+
+              "</SOAP-ENV:Body></SOAP-ENV:Envelope>");
+            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 string<script>because it ocfuses browsers</script>so 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(" [\"<escape>\", 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="<xml empty><a></a><a>1</a><a>22</a><a>333</a></xml>";
+            j=XML.toJSONObject(s);
+            System.out.println(j.toString(4));
+            System.out.println(XML.toString(j));
+            
+            s="<book><chapter>Content of the first chapter</chapter><chapter>Content of the seocd chapter      <chapter>Content of the first subchapter</chapter>      <chapter>Content of the seocd subchapter</chapter></chapter><chapter>Third Chapter</chapter></book>";
+            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="<a ichi='1' ni='2'><b>The content of b</b> and <c san='3'>The content of c</c><d>do</d><e></e><d>re</d><f/><d>mi</d></a>";
+            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="<Root><MsgType type=\"node\"><BatchType type=\"string\">111111111111111</BatchType></MsgType></Root>";
+            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("<a><b>    ");
+            } catch (Exception e) {
+            	System.out.println(e);
+            }            
+            System.out.print("Exception: ");
+            try {
+            	j=XML.toJSONObject("<a></b>    ");
+            } catch (Exception e) {
+            	System.out.println(e);
+            }            
+            System.out.print("Exception: ");
+            try {
+            	j=XML.toJSONObject("<a></a    ");
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+            System.out.print("Exception: ");
+            try {            	
+            	ja=new JSONArray(new Object());
+            	System.out.println(ja.toString());
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+
+            System.out.print("Exception: ");
+            try {            	
+            	s="[)";
+            	a=new JSONArray(s);
+            	System.out.println(a.toString());
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+
+            System.out.print("Exception: ");
+            try {            	
+                s="<xml";
+                ja=JSONML.toJSONArray(s);
+                System.out.println(ja.toString(4));
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+
+            System.out.print("Exception: ");
+            try {            	
+                s="<right></wrong>";
+                ja=JSONML.toJSONArray(s);
+                System.out.println(ja.toString(4));
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+
+            System.out.print("Exception: ");
+            try {            	
+                s="{\"koda\": true, \"koda\": true}";
+                j=new JSONObject(s);
+                System.out.println(j.toString(4));
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+
+            System.out.print("Exception: ");
+            try {            	
+                jj=new JSONStringer();
+                s=jj
+    	            .object()
+    	                .key("bosanda")
+    	                .value("MARIE HAA'S")
+    	                .key("bosanda")
+    	                .value("MARIE HAA\\'S")
+    	            .endObject()
+    	            .toString();
+                System.out.println(j.toString(4));
+            } catch (Exception e) {
+            	System.out.println(e);
+            }
+        } catch (Exception e) {
+            System.out.println(e.toString());
+        }
+    }
+}

src/main/java/systems/sdw/basetech/json/XML.java

@@ -0,0 +1,441 @@
+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;
+
+
+/**
+ * This provides static methods to convert an XML text into a JSONObject,
+ * and to covert a JSONObject into an XML text.
+ * @author JSON.org
+ * @version 2010-04-08
+ */
+public class XML {
+
+    /** The Character '&'. */
+    public static final Character AMP  =Character.valueOf('&');
+
+    /** The Character '''. */
+    public static final Character APOS =Character.valueOf('\'');
+
+    /** The Character '!'. */
+    public static final Character BANG =Character.valueOf('!');
+
+    /** The Character '='. */
+    public static final Character EQ   =Character.valueOf('=');
+
+    /** The Character '>'. */
+    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:
+     * <pre>
+     * &amp; <small>(ampersand)</small> is replaced by &amp;amp;
+     * &lt; <small>(less than)</small> is replaced by &amp;lt;
+     * &gt; <small>(greater than)</small> is replaced by &amp;gt;
+     * &quot; <small>(double quote)</small> is replaced by &amp;quot;
+     * </pre>
+     * @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("&amp;");
+                break;
+            case '<':
+                sb.append("&lt;");
+                break;
+            case '>':
+                sb.append("&gt;");
+                break;
+            case '"':
+                sb.append("&quot;");
+                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();
+
+// <!
+
+        if (t == BANG) {
+            c=x.next();
+            if (c == '-') {
+                if (x.next() == '-') {
+                    x.skipPast("-->");
+                    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 '<!'.");
+                } else if (t == LT) {
+                    i += 1;
+                } else if (t == GT) {
+                    i -= 1;
+                }
+            } while (i > 0);
+            return false;
+        } else if (t == QUEST) {
+
+// <?
+
+            x.skipPast("?>");
+            return false;
+        } else if (t == SLASH) {
+
+// Close tag </
+
+        	t=x.nextToken();
+            if (name == null) {
+                throw x.syntaxError("Mismatched close tag" + t);
+            }            
+            if (!t.equals(name)) {
+                throw x.syntaxError("Mismatched " + name + " and " + t);
+            }
+            if (x.nextToken() != GT) {
+                throw x.syntaxError("Misshaped close tag");
+            }
+            return true;
+
+        } else if (t instanceof Character) {
+            throw x.syntaxError("Misshaped tag");
+
+// Open tag <
+
+        } else {
+            n=(String)t;
+            t=null;
+            o=new JSONObject();
+            for (;;) {
+                if (t == null) {
+                    t=x.nextToken();
+                }
+
+// attribute=value
+
+                if (t instanceof String) {
+                    s=(String)t;
+                    t=x.nextToken();
+                    if (t == EQ) {
+                        t=x.nextToken();
+                        if (!(t instanceof String)) {
+                            throw x.syntaxError("Missing value");
+                        }
+                        o.accumulate(s, JSONObject.stringToValue((String)t));
+                        t=null;
+                    } else {
+                        o.accumulate(s, "");
+                    }
+
+// Empty 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
+     * <code>&lt;[ [ ]]></code> 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 <tagName>
+
+            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("</");
+                            b.append(k);
+                            b.append('>');
+                    	} else {
+                    		b.append(toString(v, k));
+                    	}
+                    }
+                } else if (v.equals("")) {
+                    b.append('<');
+                    b.append(k);
+                    b.append("/>");
+
+// Emit a new tag <k>
+
+                } else {
+                    b.append(toString(v, k));
+                }
+            }
+            if (tagName != null) {
+
+// Emit the </tagname> close tag
+
+                b.append("</");
+                b.append(tagName);
+                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 <array> 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 + "</" + tagName + ">";
+        }
+    }
+}

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<String, Character> entity;
+
+   static {
+       entity=new java.util.HashMap<String, Character>(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 <code>]]&gt;</code>.
+     * @throws JSONException If the <code>]]&gt;</code> 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:
+     *     <code>&amp;  &apos;  &gt;  &lt;  &quot;</code>.
+     * @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 (<code>< > /=! ?</code>) 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: <code>/ >=! ?</code> 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;
+    		}
+    	}
+    }
+}

src/main/webapp/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Class-Path: 
+

src/main/webapp/WEB-INF/web.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<web-app id="WebApp_ID" version="2.4"
+	xmlns="http://java.sun.com/xml/ns/j2ee"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
+
+	<display-name>ZFD</display-name>
+
+	<servlet>
+		<description>Frontcontroller</description>
+		<display-name>Frontcontroller</display-name>
+		<servlet-name>fc</servlet-name>
+		<servlet-class>systems.sdw.Frontcontroller</servlet-class>
+	</servlet>
+
+	<servlet-mapping>
+		<servlet-name>fc</servlet-name>
+		<url-pattern>/fc</url-pattern>
+	</servlet-mapping>
+
+	<session-config>
+		<session-timeout>600</session-timeout>
+	</session-config>
+
+
+	<context-param>
+		<description>Debug</description>
+		<param-name>system.debug</param-name>
+		<param-value>true</param-value>
+	</context-param>
+
+	<context-param>
+		<description>Speicherort fuer temporaere Dateien, insb. Druckerzeugnisse</description>
+		<param-name>system.defaults.tmpPath</param-name>
+		<param-value>/tmp</param-value>
+	</context-param>
+
+	<context-param>
+		<description>Wurzel der Speicherhierarchie des DMS</description>
+		<param-name>system.defaults.dmsPath</param-name>
+		<param-value>/data/dms</param-value>
+	</context-param>
+
+	<welcome-file-list>
+		<welcome-file>index.jsp</welcome-file>
+	</welcome-file-list>
+
+</web-app>