Replace Json lib

.classpath

@@ -3,8 +3,8 @@
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry exported="true" kind="lib" path="jose4j-0.9.3.jar"/>
-	<classpathentry exported="true" kind="lib" path="json-simple-1.1.1.jar"/>
 	<classpathentry exported="true" kind="lib" path="password4j-1.6.3.jar"/>
 	<classpathentry exported="true" kind="lib" path="slf4j-api-2.0.6.jar"/>
+	<classpathentry exported="true" kind="lib" path="C:/Users/jeffc/eclipse-workspace/peer-at-code-framework/PeerAtCodeParser.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/dev/peerat/framework/HttpReader.java

@@ -12,11 +12,13 @@ import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import org.json.simple.parser.JSONParser;
+import dev.peerat.framework.utils.json.Json;
+import dev.peerat.framework.utils.json.JsonParser;
 
 public class HttpReader{
 	
 	private static Pattern HEADER_PATTERN = Pattern.compile("^([^:]*):\\s+(.*)$");
+	private static JsonParser JSON_PARSER = new JsonParser();
 
 	private Socket socket;
 	private InputStream in;
@@ -79,22 +81,11 @@ public class HttpReader{
 		return result;
 	}
 	
-	public <T> T readJson() throws Exception{
+	public <J extends Json> J readJson() throws Exception{
-		String line = "";
+		int length = Integer.parseInt(this.headers.get("content-length"));
-		while (ready()){
+		//to limit
-			char[] c = new char[1];
+		char[] content = new char[length];
-			read(c);
+		return JSON_PARSER.parse(new String(content));
-			line += c[0];
-			if (c[0] == '}'){
-				Object parse;
-				try {
-					parse = new JSONParser().parse(line);
-					if (parse != null)
-						return (T) parse;
-				}catch(Exception e){}
-			}
-		}
-		return null;
 	}
 	
 	/*

src/dev/peerat/framework/utils/json/Json.java

@@ -0,0 +1,3 @@
+package dev.peerat.framework.utils.json;
+
+public interface Json{}

src/dev/peerat/framework/utils/json/JsonArray.java

@@ -0,0 +1,24 @@
+package dev.peerat.framework.utils.json;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class JsonArray implements Json{
+	
+	private List<Object> list;
+	
+	public JsonArray(){
+		this.list = new ArrayList<>();
+	}
+	
+	public void add(Object value){
+		this.list.add(value);
+	}
+	
+	@Override
+	public String toString(){
+		return list.toString();
+	}
+
+	
+}

src/dev/peerat/framework/utils/json/JsonMap.java

@@ -0,0 +1,56 @@
+package dev.peerat.framework.utils.json;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class JsonMap implements Json{
+	
+	private Map<String, Object> map;
+	
+	public JsonMap(){
+		this.map = new HashMap<>();
+	}
+	
+	public void set(String key, Object value){
+		this.map.put(key, value);
+	}
+	
+	public boolean has(String key){
+		return map.containsKey(key);
+	}
+	
+	public <E> E get(String key){
+		return (E) map.get(key);
+	}
+	
+	@Override
+	public String toString(){
+		Iterator<Entry<String, Object>> iterator = map.entrySet().iterator();
+		if(!iterator.hasNext()) return "{}";
+		StringBuilder builder= new StringBuilder('{');
+		while(iterator.hasNext()){
+			Entry<String, Object> entry = iterator.next();
+			builder.append('"');
+			builder.append(entry.getKey());
+			builder.append("\":");
+			
+			Object value = entry.getValue();
+			if(value instanceof  String){
+				builder.append('"');
+				builder.append(value);
+				builder.append('"');
+			}else if(value instanceof Character){
+				builder.append('\'');
+				builder.append(value);
+				builder.append('\'');
+			}else{
+				builder.append(value);
+			}
+			if(iterator.hasNext()) builder.append(',');
+		}
+		builder.append('}');
+		return builder.toString();
+	}
+}

src/dev/peerat/framework/utils/json/JsonParser.java

@@ -0,0 +1,147 @@
+package dev.peerat.framework.utils.json;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import be.jeffcheasey88.peeratcode.parser.Parser;
+import be.jeffcheasey88.peeratcode.parser.Token;
+import be.jeffcheasey88.peeratcode.parser.TokenType;
+import be.jeffcheasey88.peeratcode.parser.state.RedirectStateTree;
+import be.jeffcheasey88.peeratcode.parser.state.StateTree;
+
+public class JsonParser extends Parser<Json>{
+	
+	private static StateTree<Json> base;
+	
+	static{
+		base = new StateTree<>();
+		
+		StateTree<Json> content = new StateTree<>();
+		
+		StateTree<Json> content_array = new StateTree<>();
+		StateTree<Json> content_array_element = content_array.then(new RedirectStateTree<>(content, (global, local) ->{
+			List<Object> list = global.get();
+			if(list == null){
+				list = new ArrayList<>();
+				global.set(list);
+			}
+			list.add(local.get());
+		}));
+		content_array_element.end((parent, bag) -> {
+			JsonArray json = (JsonArray)parent;
+			
+			List<Object> list =  bag.get();
+			for(Object value : list){
+				json.add(convert(value));
+			}
+			return null;
+		});
+		content_array_element.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+			.then(content_array_element);
+		
+		content.then(new RedirectStateTree<>(base, (global, local) -> global.set(local.get()))).end();
+		content.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.STRING), (bag, token) -> bag.set(token))).end();
+		content.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.CHAR), (bag, token) -> bag.set(token))).end();
+		content.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.NAME), (bag, token) -> bag.set(token))).end();
+		
+		StateTree<Json> mapper = new StateTree<>();
+		StateTree<Json> mapper_key = mapper.then((validator) -> validator.validate((token) -> token.getType().equals(TokenType.STRING), (bag, token) -> {
+			Map<Token, Object> map = bag.get("map");
+			if(map == null){
+				map = new HashMap<>();
+				bag.set("map", map);
+			}
+			map.put(token, null);
+			bag.set("last", token);
+		}));
+		StateTree<Json> mapper_value = mapper_key.then((validator) -> validator.validate((token) -> token.getValue().equals(":")))
+			.then(new RedirectStateTree<>(content, (global, local) -> {
+				global.<Map<Token, Object>>get("map").put(global.<Token>get("last"), local.get());
+			}));
+		
+		mapper_value.end((parent, bag) -> {
+			Map<Token, Object> map = bag.get("map");
+			JsonMap jMap = (JsonMap)parent;
+			for(Entry<Token, Object> entry : map.entrySet()){
+				jMap.set(entry.getKey().getValue(), convert(entry.getValue()));
+			}
+			return null;
+		});
+		mapper_value.then((validator) -> validator.validate((token) -> token.getValue().equals(",")))
+			.then(mapper_key);
+		
+		
+		base.then((validator) -> validator.validate((token) -> token.getValue().equals("{")))
+			.<Json>end((parent, bag) -> {
+				JsonMap result = new JsonMap();
+				bag.set(result);
+				if(parent instanceof JsonContainer) ((JsonContainer)parent).value = result;
+				return result;
+			})
+				.unique(mapper)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("}")))
+				.end();
+		
+		base.then((validator) -> validator.validate((token) -> token.getValue().equals("[")))
+			.<Json>end((parent, bag) -> {
+				JsonArray result = new JsonArray();
+				bag.set(result);
+				if(parent instanceof JsonContainer) ((JsonContainer)parent).value = result;
+				return result;
+			})
+				.unique(content_array)
+				.unique((validator) -> validator.validate((token) -> token.getValue().equals("]")))
+				.end();
+	}
+	
+	private static Object convert(Object value){
+		if(value instanceof Token){
+			Token token = (Token) value;
+			String content = token.getValue();
+			if(token.getType().equals(TokenType.STRING)){
+				return content;
+			}else if(token.getType().equals(TokenType.CHAR)){
+				return content.charAt(0);
+			}else{
+				try{
+					return Long.parseLong(content);
+				}catch(Exception _){
+					try {
+						return Boolean.parseBoolean(content);
+					}catch(Exception __){
+						try{
+							return Double.parseDouble(content);
+						}catch(Exception ___){}
+					}
+				}
+			}
+		}
+		return value;
+	}
+	
+	public JsonParser(){
+		setTokenizer(new JsonTokenizer());
+		setStateTree(base);
+	}
+	
+	public <J extends Json> J parse(String content) throws Exception{
+		JsonContainer container = new JsonContainer();
+		parse(content,  container);
+		return container.getValue();
+	}
+	
+	private static class JsonContainer implements Json{
+		
+		private Json value;
+		
+		public JsonContainer(){}
+		
+		public <J extends Json> J getValue(){
+			return (J) this.value;
+		}
+		
+	}
+}

src/dev/peerat/framework/utils/json/JsonTokenizer.java

@@ -0,0 +1,65 @@
+package dev.peerat.framework.utils.json;
+
+import be.jeffcheasey88.peeratcode.parser.Token;
+import be.jeffcheasey88.peeratcode.parser.TokenType;
+import be.jeffcheasey88.peeratcode.parser.Tokenizer;
+
+public class JsonTokenizer extends Tokenizer{
+
+	@Override
+	public void parse(String line){
+		for(int i = 0; i < line.length(); i++){
+			char c = line.charAt(i);
+			
+			if(isValidName(c)){
+				String buffer =  ""+c;
+				int j = i+1;
+				for(; j < line.length(); j++){
+					c = line.charAt(j);
+					if(isValidName(c)) buffer+=c;
+					else break;
+				}
+				getTokens().add(new Token(1, i+1, buffer, TokenType.NAME));
+				i=j-1;
+			}else if(Character.isWhitespace(c)) continue;
+			else{
+				if(c == '"'){
+					String buffer = "";
+					int j = i+1;
+					for(; j < line.length(); j++){
+						c = line.charAt(j);
+						if(c == '\\'){
+							buffer+=c+line.charAt(++j);
+						}
+						if(c == '\"') break;
+						buffer+=c;
+					}
+					getTokens().add(new Token(1, i+1, buffer, TokenType.STRING));
+					i=j;
+					continue;
+				}
+				if(c == '\''){
+					String buffer = "";
+					int j = i+1;
+					for(; j < line.length(); j++){
+						c = line.charAt(j);
+						if(c == '\\'){
+							buffer+=c+line.charAt(++j);
+						}
+						if(c == '\'') break;
+						buffer+=c;
+					}
+					getTokens().add(new Token(1, i+1, buffer, TokenType.CHAR));
+					i=j;
+					continue;
+				}
+				getTokens().add(new Token(1, i+1, ""+c, TokenType.DELIMITER));
+			}
+		}
+	}
+	
+	private boolean isValidName(char c){
+		return c == '_' || c == '-' || c == '$' || Character.isAlphabetic(c) || Character.isDigit(c);
+	}
+	
+}