diff --git a/models/CustomerManagement.Json b/models/CustomerManagement.Json new file mode 100644 index 0000000..eb7377e --- /dev/null +++ b/models/CustomerManagement.Json @@ -0,0 +1,10 @@ +{ + "relations": [], + "transfer": { + "src": "Companies.{company}", + "dst": "customers.{customer}", + "data": {"type": "String", "name": "address"}, + "style": "PULL", + "multiplicity": "1:*" + } +} \ No newline at end of file diff --git a/src/main/java/Main.java b/src/main/java/Main.java index 70613b6..0040c85 100644 --- a/src/main/java/Main.java +++ b/src/main/java/Main.java @@ -6,31 +6,30 @@ public class Main { - public static void main(String[] args) { - List srcEdges = new ArrayList<>(); - List dstEdges = new ArrayList<>(); - ObjectNode companies = new ObjectNode("Companies"); - ObjectNode company = new ObjectNode("Company"); - ObjectNode customers = new ObjectNode("Customers"); - ObjectNode customer = new ObjectNode("Customer"); - ObjectNode address = new ObjectNode("String"); - ReferenceEdge srcEdge = new ReferenceEdge(companies, company, "company", "String"); - srcEdges.add(srcEdge); - ReferenceEdge dstEdge = new ReferenceEdge(customers, customer, "customer", "String"); - dstEdges.add(dstEdge); - List relations = new ArrayList<>(); + public static void main(String[] args) { + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode companies = new ObjectNode("Companies"); + ObjectNode company = new ObjectNode("Company"); + ObjectNode customers = new ObjectNode("Customers"); + ObjectNode customer = new ObjectNode("Customer"); + ObjectNode address = new ObjectNode("String"); + ReferenceEdge srcEdge = new ReferenceEdge(companies, company, "company", "String"); + srcEdges.add(srcEdge); + ReferenceEdge dstEdge = new ReferenceEdge(customers, customer, "customer", "String"); + dstEdges.add(dstEdge); + List relations = new ArrayList<>(); // Relation transferRelation = new Relation(company, customer, MultiplicityValue.OneToOne); - Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToMany); - DataTransferContext context = new DataTransferContext(relations, transferRelation, address, "address", PushPullValue.PULL); - - DataTransferDesign design; - try { - design = new DataTransferDesign(context); - System.out.println(ASTGenerator.generate(design)); - } catch (IllegalRelationException e) { - e.printStackTrace(); - } - - } + Relation transferRelation = new Relation(srcEdges, dstEdges, MultiplicityValue.OneToMany); + DataTransferContext context = new DataTransferContext(relations, transferRelation, address, "address", PushPullValue.PULL); + + DataTransferDesign design; + try { + design = new DataTransferDesign(context); + System.out.println(ASTGenerator.generate(design)); + } catch (IllegalRelationException e) { + e.printStackTrace(); + } + } } diff --git a/src/main/java/models/objectOrientedTransfer/DataTransferContext.java b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java index 4026628..9bfe279 100644 --- a/src/main/java/models/objectOrientedTransfer/DataTransferContext.java +++ b/src/main/java/models/objectOrientedTransfer/DataTransferContext.java @@ -1,70 +1,241 @@ package models.objectOrientedTransfer; +import parser.ArrayValue; +import parser.JsonValue; +import parser.StringValue; +import parser.Value; +import parser.exceptions.ExpectedJsonValue; + +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; /** * The reference context and properties of specific data transfer. - * + * * @author Nitta * */ public class DataTransferContext { - private List relations; - private Relation transferRelation; - private ObjectNode dataType; - private String dataName; - private PushPullValue transferStyle; - - public DataTransferContext(List relations, Relation transferRelation, ObjectNode dataType, String dataName, PushPullValue transferStyle) { - this.relations = relations; - this.transferRelation = transferRelation; - this.dataType = dataType; - this.dataName = dataName; - this.transferStyle = transferStyle; - } - - public List getRelations() { - return relations; - } - - public Relation getTransferRelation() { - return transferRelation; - } - - public boolean isFlat() { - return transferRelation.isFlat(); - } - - public List getSrcResource() { - return transferRelation.getSrcResource(); - } + private List relations; + private Relation transferRelation; + private ObjectNode dataType; + private String dataName; + private PushPullValue transferStyle; + private Map objectNodeMap = new HashMap<>(); - public List getDstResource() { - return transferRelation.getDstResource(); - } - - public ObjectNode getSrcFirstResource() { - return transferRelation.getSrcFirstResource(); - } + public DataTransferContext(Value jsonValue) { + setDataTransferContext(jsonValue); + } - public ObjectNode getDstFirstResource() { - return transferRelation.getDstFirstResource(); - } + public DataTransferContext(List relations, Relation transferRelation, ObjectNode dataType, String dataName, PushPullValue transferStyle) { + this.relations = relations; + this.transferRelation = transferRelation; + this.dataType = dataType; + this.dataName = dataName; + this.transferStyle = transferStyle; + } + + public List getRelations() { + return relations; + } + + public Relation getTransferRelation() { + return transferRelation; + } + + public boolean isFlat() { + return transferRelation.isFlat(); + } + + public List getSrcResource() { + return transferRelation.getSrcResource(); + } + + public List getDstResource() { + return transferRelation.getDstResource(); + } + + public ObjectNode getSrcFirstResource() { + return transferRelation.getSrcFirstResource(); + } + + public ObjectNode getDstFirstResource() { + return transferRelation.getDstFirstResource(); + } - public MultiplicityValue getTransferMultiplicity() { - return transferRelation.getMultiplicity(); - } + public MultiplicityValue getTransferMultiplicity() { + return transferRelation.getMultiplicity(); + } - public ObjectNode getDataType() { - return dataType; - } + public ObjectNode getDataType() { + return dataType; + } - public String getDataName() { - return dataName; - } + public String getDataName() { + return dataName; + } - public PushPullValue getTransferStyle() { - return transferStyle; - } + public PushPullValue getTransferStyle() { + return transferStyle; + } + + private void setDataTransferContext(Value value) { + if (value instanceof JsonValue) { + for (StringValue keyValue : ((JsonValue) value).getJson().keySet()) { + String key = keyValue.getStringValue(); + if (key.equals("relations")) {//この部分は動作未確認(おそらくまだ動かない) + relations = new ArrayList<>(); + ArrayValue arrayValue = ((ArrayValue)((JsonValue) value).getValue(keyValue)); + List relationValues = arrayValue.getValues(); + for(Value relationValue:relationValues){ + relations.add(getRelation(relationValue)); + } + } else if (key.equals("transfer")) { + transferRelation = getRelation(((JsonValue) value).getValue(keyValue)); + } + } + } + } + + private Relation getRelation(Value value){ + if (value instanceof JsonValue) { + MultiplicityValue multiplicityValue = null; + List srcEdges = new ArrayList<>(); + List dstEdges = new ArrayList<>(); + ObjectNode src = null; + ObjectNode dst = null; + for (StringValue keyValue : ((JsonValue) value).getJson().keySet()) { + String key = keyValue.getStringValue(); + if (key.equals("src")) { + src = setEdges((StringValue) ((JsonValue) value).getValue(keyValue), srcEdges); + } else if (key.equals("dst")) { + dst = setEdges((StringValue) ((JsonValue) value).getValue(keyValue), dstEdges); + } else if (key.equals("style")) { + setTransferStyle((StringValue) ((JsonValue) value).getValue(keyValue)); + } else if (key.equals("multiplicity")) { + StringValue multi = (StringValue) ((JsonValue) value).getValue(keyValue); + String multiplicity = multi.getStringValue(); + if (multiplicity.equals("*:1")) { + multiplicityValue = MultiplicityValue.ManyToOne; + } else if (multiplicity.equals("1:1")) { + multiplicityValue = MultiplicityValue.OneToOne; + } else if (multiplicity.equals("*:*")) { + multiplicityValue = MultiplicityValue.ManyToMany; + } else if (multiplicity.equals("1:*")) { + multiplicityValue = MultiplicityValue.OneToMany; + } + } else if (key.equals("data")) { + setTransferData(((JsonValue) value).getValue(keyValue)); + } + } + if (multiplicityValue == null) { + throw new RuntimeException("multiplicityが存在していません"); + } + if(src != null&&dst != null){//両方単独ObjectNode + return new Relation(src,dst,multiplicityValue); + }else if(src == null&&dst != null){//片方単独 + return new Relation(srcEdges,dst,multiplicityValue); + }else if(src != null&&dst == null){//上と同じ + return new Relation(src,dstEdges,multiplicityValue); + }else{//両方複数 + return new Relation(srcEdges,dstEdges,multiplicityValue); + } + } + throw new ExpectedJsonValue("Jsonではありません。"); + } + + private void setTransferStyle(StringValue stringValue){ + String style = stringValue.getStringValue(); + if (style.equals("PUSH")) { + transferStyle = PushPullValue.PUSH; + } else if (style.equals("PULL")) { + transferStyle = PushPullValue.PULL; + } + } + + private void setTransferData(Value dataTransferValue){ + if (dataTransferValue instanceof JsonValue) { + for (StringValue dataTransferValueKeyValue : ((JsonValue) dataTransferValue).getJson().keySet()) { + String dataTransferValueKey = dataTransferValueKeyValue.getStringValue(); + if (dataTransferValueKey.equals("type")) { + String type = ((StringValue) ((JsonValue) dataTransferValue).getValue(dataTransferValueKeyValue)).getStringValue(); + dataType = new ObjectNode(type); + } else if (dataTransferValueKey.equals("name")) { + String name = ((StringValue) ((JsonValue) dataTransferValue).getValue(dataTransferValueKeyValue)).getStringValue(); + dataName = name; + } + } + } else { + throw new ExpectedJsonValue("jsonのtransferのdataが足りていません"); + } + } + + private ObjectNode setEdges(StringValue stringValue, List edges) {//objectNodeの場合はobjectNodeを返したい。 + String S = stringValue.getStringValue(); + int cur = 0; + ArrayList list = new ArrayList<>(); + while (cur < S.length()) { + StringBuilder variable = new StringBuilder(); + while (cur < S.length() && S.charAt(cur) != '.') { + variable.append(S.charAt(cur)); + cur++; + } + list.add(variable.toString()); + cur++; + } + if(list.size() == 1){//一つだけの場合はobjectNodeを返す + String src = list.get(0); + objectNodeMap.put(src, new ObjectNode(src)); + return objectNodeMap.get(src); + } + for (int i = 0; i < list.size() - 1; i++) { + String src = list.get(i); + String dst = list.get(i + 1); + if (dst.charAt(0) == '{' && dst.charAt(dst.length() - 1) == '}') {//oneToMany + dst = dst.substring(1, dst.length() - 1); + if(!objectNodeMap.containsKey(dst)){ + objectNodeMap.put(dst, new ObjectNode(dst)); + } + if (src.charAt(0) == '{' && src.charAt(src.length() - 1) == '}') { + src = src.substring(1, src.length() - 1); + if (!objectNodeMap.containsKey(src)) { + objectNodeMap.put(src, new ObjectNode(src)); + } + } else { + if (!objectNodeMap.containsKey(src)) { + objectNodeMap.put(src, new ObjectNode(src)); + } + } + edges.add(new ReferenceEdge(objectNodeMap.get(src), objectNodeMap.get(dst), convertTheFirstCharacterToLowerCase(dst), "String")); + } else {//oneToOne + if(!objectNodeMap.containsKey(dst)){ + objectNodeMap.put(dst, new ObjectNode(dst)); + } + if (src.charAt(0) == '{' && src.charAt(src.length() - 1) == '}') { + src = src.substring(1, src.length() - 1); + if (!objectNodeMap.containsKey(src)) { + objectNodeMap.put(src, new ObjectNode(src)); + } + } else { + if (!objectNodeMap.containsKey(src)) { + objectNodeMap.put(src, new ObjectNode(src)); + } + } + edges.add(new ReferenceEdge(objectNodeMap.get(src), objectNodeMap.get(dst), convertTheFirstCharacterToLowerCase(dst))); + } + } + return null; + } + + private String convertTheFirstCharacterToLowerCase(String s){ + if(Character.isUpperCase(s.charAt(0))){ + s = s.substring(0,1).toLowerCase() + s.substring(1); + return s; + }else{ + return s; + } + } } diff --git a/src/main/java/models/objectOrientedTransfer/Relation.java b/src/main/java/models/objectOrientedTransfer/Relation.java index e955b06..0cd68aa 100644 --- a/src/main/java/models/objectOrientedTransfer/Relation.java +++ b/src/main/java/models/objectOrientedTransfer/Relation.java @@ -10,7 +10,7 @@ private boolean isFlat = false; private ObjectNode srcResourceNode; private ObjectNode dstResourceNode; - + public Relation(List srcResource, List dstResource, MultiplicityValue multiplicity) { isFlat = false; this.srcResource = srcResource; @@ -42,11 +42,11 @@ this.dstResourceNode = dstResourceNode; this.multiplicity = multiplicity; } - + public boolean isFlat() { return isFlat; } - + public List getSrcResource() { return srcResource; } @@ -54,14 +54,14 @@ public List getDstResource() { return dstResource; } - + public ObjectNode getSrcFirstResource() { if (isFlat) { return srcResourceNode; } return (ObjectNode) srcResource.getFirst().getSource(); } - + public ObjectNode getDstFirstResource() { if (isFlat) { return dstResourceNode; diff --git a/src/main/java/parser/ArrayValue.java b/src/main/java/parser/ArrayValue.java new file mode 100644 index 0000000..a958863 --- /dev/null +++ b/src/main/java/parser/ArrayValue.java @@ -0,0 +1,20 @@ +package parser; + +import java.util.*; + +public class ArrayValue extends Value { + List values = new ArrayList<>(); + + public void addValue(Value value) { + values.add(value); + } + + public List getValues() { + return values; + } + + @Override + public String toString() { + return values.toString(); + } +} diff --git a/src/main/java/parser/IntegerValue.java b/src/main/java/parser/IntegerValue.java new file mode 100644 index 0000000..ad239d7 --- /dev/null +++ b/src/main/java/parser/IntegerValue.java @@ -0,0 +1,18 @@ +package parser; + +public class IntegerValue extends Value { + Integer intValue; + + public void setIntValue(Integer intValue) { + this.intValue = intValue; + } + + public Integer getIntValue() { + return intValue; + } + + @Override + public String toString() { + return String.valueOf(intValue); + } +} diff --git a/src/main/java/parser/JsonValue.java b/src/main/java/parser/JsonValue.java new file mode 100644 index 0000000..428c30d --- /dev/null +++ b/src/main/java/parser/JsonValue.java @@ -0,0 +1,34 @@ +package parser; + +import java.util.*; + +public class JsonValue extends Value { + Map json = new HashMap<>(); + + public Map getJson() { + return json; + } + + public Value getValue(StringValue key) { + return json.get(key); + } + + public void setJsonValue(StringValue key, Value value) { + json.put(key, value); + } + + @Override + public String toString() { + StringBuilder stringBuilder = new StringBuilder(); + stringBuilder.append("{"); + for (StringValue key : json.keySet()) { + stringBuilder.append(key).append(" : "); + stringBuilder.append(json.get(key)).append(" ,"); + } + if (stringBuilder.length() >= 2 && stringBuilder.substring(stringBuilder.length() - 2, stringBuilder.length()).equals(" ,")) { + stringBuilder.delete(stringBuilder.length() - 2, stringBuilder.length()); + } + stringBuilder.append(" }"); + return stringBuilder.toString(); + } +} diff --git a/src/main/java/parser/Parser.java b/src/main/java/parser/Parser.java new file mode 100644 index 0000000..0c20d1a --- /dev/null +++ b/src/main/java/parser/Parser.java @@ -0,0 +1,320 @@ +package parser; + +import models.objectOrientedTransfer.*; +import parser.exceptions.ExpectedArrayValue; +import parser.exceptions.ExpectedJsonValue; +import parser.exceptions.ExpectedStringValue; + +import java.io.BufferedReader; +import java.io.IOException; +import java.util.*; + +public class Parser { + public TokenStream tokenStream; + + public static final String LEFT_CURLY_BRACKET = "{"; + public static final String RIGHT_CURLY_BRACKET = "}"; + public static final String LEFT_CURLY_BRACKET_REGX = "\\{"; + public static final String RIGHT_CURLY_BRACKET_REGX = "\\}"; + public static final String LEFT_SQUARE_BRACKET = "["; + public static final String RIGHT_SQUARE_BRACKET = "]"; + public static final String LEFT_SQUARE_BRACKET_REGX = "\\["; + public static final String RIGHT_SQUARE_BRACKET_REGX = "\\]"; + public static final String COMMA = ","; + public static final String COLON = ":"; + public static final String DOUBLE_QUOT = "\""; + + public Parser() { + Scanner sc = new Scanner(System.in); + StringBuilder s = new StringBuilder(); + System.out.println("Jsonをはりつけてください"); + while (true) { + String S = sc.nextLine(); + if (S.equals("")) { + break; + } + s.append(S); + } + tokenStream = new TokenStream(); + tokenStream.addLine(s.toString()); + } + + public Parser(final BufferedReader reader) { + this.tokenStream = new TokenStream(); + try { + String line; + while ((line = reader.readLine()) != null) { + tokenStream.addLine(line); + } + reader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public Value getValue() { + return parseValue(tokenStream); + } + + public Value parseValue(TokenStream tokenStream) throws ExpectedJsonValue, ExpectedArrayValue, ExpectedStringValue { + if (tokenStream.checkNext().equals(LEFT_CURLY_BRACKET)) { + tokenStream.next(); + JsonValue jsonValue = parseJsonValue(tokenStream); + if (tokenStream.checkNext().equals(RIGHT_CURLY_BRACKET)) { + tokenStream.next(); + return jsonValue; + } else { + throw new ExpectedJsonValue(String.valueOf(tokenStream.getLine())); + } + } else if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { + tokenStream.next(); + ArrayValue arrayValue = parseArrayValue(tokenStream); + if (tokenStream.checkNext().equals(RIGHT_SQUARE_BRACKET)) { + tokenStream.next(); + return arrayValue; + } else { + throw new ExpectedArrayValue(String.valueOf(tokenStream.getLine())); + } + } else if (tokenStream.checkNext().equals(DOUBLE_QUOT)) { + tokenStream.next(); + StringValue stringValue = parseStringValue(tokenStream); + if (tokenStream.checkNext().equals(DOUBLE_QUOT)) { + tokenStream.next(); + return stringValue; + } else { + throw new ExpectedStringValue(String.valueOf(tokenStream.getLine())); + } + } else if (Character.isDigit(tokenStream.checkNext().charAt(0))) { + return parseIntegerValue(tokenStream); + } + throw new RuntimeException(String.valueOf(tokenStream.getLine())); + } + + public JsonValue parseJsonValue(TokenStream tokenStream) throws ExpectedStringValue { + JsonValue jsonValue = new JsonValue(); + //要素が0 + if (tokenStream.checkNext().equals(RIGHT_CURLY_BRACKET)) { + return jsonValue; + } + while (true) { + //key + Value keyValue = parseValue(tokenStream); + if (!(keyValue instanceof StringValue)) { + throw new ExpectedStringValue(String.valueOf(tokenStream.getLine())); + } + expect(tokenStream, COLON); + tokenStream.next();//COLON + //value + Value value = parseValue(tokenStream); + jsonValue.setJsonValue((StringValue) keyValue, value); + if (!tokenStream.checkNext().equals(COMMA)) { + break; + } + tokenStream.next(); + } + return jsonValue; + } + + public ArrayValue parseArrayValue(TokenStream tokenStream) { + ArrayValue arrayValue = new ArrayValue(); + //要素が0 + if (tokenStream.checkNext().equals(RIGHT_SQUARE_BRACKET)) { + return arrayValue; + } + while (true) { + Value value = parseValue(tokenStream); + arrayValue.addValue(value); + if (!tokenStream.checkNext().equals(COMMA)) { + break; + } + tokenStream.next();//COMMA + } + return arrayValue; + } + + public IntegerValue parseIntegerValue(TokenStream tokenStream) { + IntegerValue integerValue = new IntegerValue(); + StringBuilder stringBuilder = new StringBuilder(); + while (Character.isDigit(tokenStream.checkNext().charAt(0))) { + stringBuilder.append(tokenStream.next()); + } + integerValue.setIntValue(Integer.valueOf(stringBuilder.toString())); + return integerValue; + } + + public StringValue parseStringValue(TokenStream tokenStream) { + StringValue stringValue = new StringValue(); + StringBuilder stringBuilder = new StringBuilder(); + while (!tokenStream.checkNext().equals(DOUBLE_QUOT)) { + stringBuilder.append(tokenStream.next()); + } + stringValue.setStringValue(stringBuilder.toString()); + return stringValue; + } + + public void expect(TokenStream tokenStream, String expect) { + if (!tokenStream.checkNext().equals(expect)) { + throw new RuntimeException("expect" + expect + "but" + tokenStream.checkNext() + " line" + tokenStream.getLine()); + } + } + + public static class TokenStream { + private ArrayList> tokens = new ArrayList<>(); + private ArrayList lines = new ArrayList<>(); + private int line = 0; + private int n = 0; + + public TokenStream() { + line = 0; + n = 0; + } + + public void addLine(String line) { + lines.add(line); + line = line.trim(); + ArrayList tokenList = splitByDoubleQuotation(line); + tokenList = splitBy(tokenList, COMMA, COMMA); + tokenList = splitBy(tokenList, COLON, COLON); + tokenList = splitBy(tokenList, LEFT_CURLY_BRACKET, LEFT_CURLY_BRACKET_REGX); + tokenList = splitBy(tokenList, RIGHT_CURLY_BRACKET, RIGHT_CURLY_BRACKET_REGX); + tokenList = splitBy(tokenList, LEFT_SQUARE_BRACKET, LEFT_SQUARE_BRACKET_REGX); + tokenList = splitBy(tokenList, RIGHT_SQUARE_BRACKET, RIGHT_SQUARE_BRACKET_REGX); + tokens.add(tokenList); + } + + private ArrayList splitBy(final List tokens, final String delimiter, final String delimiterRegx) { + ArrayList newTokens = new ArrayList<>(); + for (Token token : tokens) { + if (token.isAtomic()) { + newTokens.add(token); + } else { + String[] splitTokens = token.split(delimiterRegx); + boolean fFirstToken = true; + for (String t : splitTokens) { + if (!fFirstToken) { + newTokens.add(new Token(delimiter, true)); + } + if (t.length() > 0) { + newTokens.add(new Token(t)); + } + fFirstToken = false; + } + while (token.endsWith(delimiter)) { + newTokens.add(new Token(delimiter, true)); + token = token.substring(0, token.length() - 1); + } + } + } + return newTokens; + } + + private ArrayList splitByDoubleQuotation(String line) { + ArrayList newTokens = new ArrayList<>(); + String[] tokens = line.split(DOUBLE_QUOT); + boolean fFirstToken = true; + for (int i = 0; i < tokens.length; i++) { + String token = tokens[i]; + if (!fFirstToken) { + newTokens.add(new Token(DOUBLE_QUOT, true)); + } + if (!fFirstToken || token.length() > 0) { + if (i % 2 == 0) { + for (String t : token.split("[ \t]")) { + newTokens.add(new Token(t)); + } + } else { + // string literal + newTokens.add(new Token(token, true)); + } + } + fFirstToken = false; + } + if (line.endsWith(DOUBLE_QUOT)) { + newTokens.add(new Token(DOUBLE_QUOT, true)); + } + return newTokens; + } + + public String next() { + if (line >= tokens.size()) return null; + while (n >= tokens.get(line).size()) { + line++; + n = 0; + if (line >= tokens.size()) return null; + } + String token = tokens.get(line).get(n).getTokenStr(); + n++; + return token; + } + + public String checkNext() { + if (line >= tokens.size()) return null; + while (n >= tokens.get(line).size()) { + line++; + n = 0; + if (line >= tokens.size()) return null; + } + return tokens.get(line).get(n).getTokenStr(); + } + + public boolean hasNext() { + if (line >= tokens.size()) return false; + while (n >= tokens.get(line).size()) { + line++; + n = 0; + if (line >= tokens.size()) return false; + } + return true; + } + + public int getLine() { + return line; + } + + public String getSourceText(int from, int to) { + String text = ""; + for (int l = from; l <= to; l++) { + text += lines.get(l) + "\n"; + } + return text; + } + } + + public static class Token { + String token; + boolean isAtomic = false; + + public Token(String token) { + this.token = token; + } + + public Token(String token, boolean isAtomic) { + this.token = token; + this.isAtomic = isAtomic; + } + + public String getTokenStr() { + return token; + } + + public boolean isAtomic() { + return isAtomic; + } + + public String[] split(String delimiterRegx) { + return token.split(delimiterRegx); + } + + public boolean endsWith(String delimiter) { + return token.endsWith(delimiter); + } + + public int length() { + return token.length(); + } + + public Token substring(int beginIdx, int endIdx) { + return new Token(token.substring(beginIdx, endIdx)); + } + } +} diff --git a/src/main/java/parser/StringValue.java b/src/main/java/parser/StringValue.java new file mode 100644 index 0000000..d3f0021 --- /dev/null +++ b/src/main/java/parser/StringValue.java @@ -0,0 +1,18 @@ +package parser; + +public class StringValue extends Value { + String stringValue; + + public void setStringValue(String stringValue) { + this.stringValue = stringValue; + } + + public String getStringValue() { + return stringValue; + } + + @Override + public String toString() { + return stringValue; + } +} diff --git a/src/main/java/parser/Value.java b/src/main/java/parser/Value.java new file mode 100644 index 0000000..8a4bf2b --- /dev/null +++ b/src/main/java/parser/Value.java @@ -0,0 +1,6 @@ +package parser; + +public abstract class Value { + + public abstract String toString(); +} diff --git a/src/main/java/parser/exceptions/ExpectedArrayValue.java b/src/main/java/parser/exceptions/ExpectedArrayValue.java new file mode 100644 index 0000000..788b24c --- /dev/null +++ b/src/main/java/parser/exceptions/ExpectedArrayValue.java @@ -0,0 +1,7 @@ +package parser.exceptions; + +public class ExpectedArrayValue extends RuntimeException { + public ExpectedArrayValue(String message) { + super(message); + } +} diff --git a/src/main/java/parser/exceptions/ExpectedJsonValue.java b/src/main/java/parser/exceptions/ExpectedJsonValue.java new file mode 100644 index 0000000..1759614 --- /dev/null +++ b/src/main/java/parser/exceptions/ExpectedJsonValue.java @@ -0,0 +1,7 @@ +package parser.exceptions; + +public class ExpectedJsonValue extends RuntimeException { + public ExpectedJsonValue(String message) { + super(message); + } +} diff --git a/src/main/java/parser/exceptions/ExpectedStringValue.java b/src/main/java/parser/exceptions/ExpectedStringValue.java new file mode 100644 index 0000000..81ac6cf --- /dev/null +++ b/src/main/java/parser/exceptions/ExpectedStringValue.java @@ -0,0 +1,7 @@ +package parser.exceptions; + +public class ExpectedStringValue extends RuntimeException { + public ExpectedStringValue(String message) { + super(message); + } +} diff --git a/src/test/java/parser/TestParser.java b/src/test/java/parser/TestParser.java new file mode 100644 index 0000000..c950e0c --- /dev/null +++ b/src/test/java/parser/TestParser.java @@ -0,0 +1,37 @@ +package parser; + +import generators.ASTGenerator; +import models.objectOrientedTransfer.DataTransferContext; +import models.objectOrientedTransfer.DataTransferDesign; +import models.objectOrientedTransfer.IllegalRelationException; +import org.junit.jupiter.api.Test; +import parser.exceptions.ExpectedArrayValue; +import parser.exceptions.ExpectedJsonValue; +import parser.exceptions.ExpectedStringValue; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; + +public class TestParser { + + @Test + void testCustomerManagement(){ + File file = new File("models/CustomerManagement.Json"); + try { + Parser parser = new Parser(new BufferedReader(new FileReader(file))); + Value jsonValue = parser.getValue(); + DataTransferContext context = new DataTransferContext(jsonValue); + DataTransferDesign design; + try { + design = new DataTransferDesign(context); + System.out.println(ASTGenerator.generate(design)); + } catch (IllegalRelationException e) { + e.printStackTrace(); + } + } catch (ExpectedArrayValue | ExpectedStringValue | ExpectedJsonValue | FileNotFoundException e) { + e.printStackTrace(); + } + } +}