@Restrict(UnitRole.DEFECTEDIT)
public static void deleteComment(Long commentId) {
DefectComment defectComment = DefectComment.find("id=?", commentId).first();
if (defectComment == null) {
Logger.error(Logger.LogType.TECHNICAL, "Could not find comment %s for deletion", commentId);
notFound("Sorry, the selected comment could not be found. Please refresh the page");
}
try {
defectComment.delete();
} catch (Throwable t) {
Logger.error(Logger.LogType.DB, "Error deleting comment %s", commentId);
error("An error occurred while deleting the comment, please try again");
}
ok();
}
@Restrict(UnitRole.DEFECTDELETE)
public static void deleteDefect(Long defectId) {
Defect defect = Lookups.getDefect(defectId);
if (defect == null) {
Logger.error(Logger.LogType.TECHNICAL, "Could not find defect for deletion %s", defectId);
notFound("Sorry, the selected defect could not be found. Please refresh the page");
}
try {
defect.delete();
} catch (Throwable t) {
Logger.error(Logger.LogType.DB, "Error deleting defect %s", defectId);
error(
String.format(
"An error occurred while deleting defect %s, please try again", defect.naturalId));
}
ok();
}
@Restrict(UnitRole.DEFECTCREATE)
public static void createDefect(@Valid Defect defect) {
defect.submittedBy = getConnectedUser();
defect.account = getConnectedUserAccount();
defect.project = getActiveProject();
defect.status = DefectStatus.getDefaultDefectStatus();
boolean created = defect.create();
if (!created) {
Logger.error(Logger.LogType.DB, "Error while creating defect");
error("An error occurred while saving the defect, please try again");
}
// linking to test instance
String runIdParam = params.get("runId");
if (StringUtils.isNotEmpty(runIdParam)) {
try {
Long runId = Long.valueOf(runIdParam);
if (runId != null) {
Instance instance =
Run.find("select r.instance from Run r where r.id = ?", runId).first();
instance.defects.add(defect);
try {
instance.save();
} catch (Throwable t) {
Logger.error(
Logger.LogType.DB,
"Error while updating defect instance during linking to defefct %s",
defect.getId());
error(
String.format(
"An error occurred while linking the newly created defect %s to test instance %s. Please try again.",
defect.naturalId, instance.naturalId));
}
}
} catch (NumberFormatException nfe) {
Logger.error(
Logger.LogType.SECURITY,
"Invalid value '%s' for runId parameter passed during defect creation",
runIdParam);
error();
}
}
ok();
}
@Override
public void transform(final CommonTree ast) {
LOGGER.info("DatatypeInfoMapper.transform..." + ast);
namespaceStack.clear();
this.datatypeInfos = new ArrayList<DatatypeInfo>(ast.getChildCount());
try {
for (int i = 0; i < ast.getChildCount(); i++) {
walk(ast.getChild(i), null);
}
} catch (RuntimeException e) {
LOGGER.error(e);
throw e;
}
LOGGER.info("DONE: " + references.size() + " loaded.");
}
@Restrict(UnitRole.DEFECTVIEW)
public static void defectDetails(Long baseObjectId, String[] fields) {
Defect defect = Lookups.getDefect(baseObjectId);
if (defect == null) {
Logger.error(Logger.LogType.TECHNICAL, "Could not find defect with ID %s", defect.id);
notFound("Sorry, the selected defect could not be found. Please refresh the page");
}
renderFields(defect, fields);
}
@Restrict(UnitRole.DEFECTEDIT)
public static void updateDefect(@Valid Defect defect) {
Defect d = Lookups.getDefect(defect.getId());
if (d == null) {
Logger.error(Logger.LogType.TECHNICAL, "Could not find defect with ID %s", defect.getId());
notFound("Sorry, the selected defect could not be found. Please refresh the page");
}
d.name = defect.name;
d.description = defect.description;
d.assignedTo = defect.assignedTo;
d.status = defect.status;
try {
d.save();
} catch (Throwable t) {
Logger.error(Logger.LogType.DB, "Error updating defect");
error("An error occurred while saving the defect, please try again.");
}
ok();
}
@Restrict(UnitRole.DEFECTVIEW)
public static void defectDescription(Long defectId) {
Defect defect = Lookups.getDefect(defectId);
if (defect == null) {
Logger.error(Logger.LogType.TECHNICAL, "Could not find defect with ID %s", defectId);
notFound("Sorry, the selected defect could not be found. Please refresh the page");
}
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("defectTitle", defect.name);
jsonObject.addProperty(
"defectAssignedTo", defect.assignedTo == null ? "" : defect.assignedTo.toString());
jsonObject.addProperty(
"defectSubmittedBy", defect.submittedBy == null ? "" : defect.submittedBy.toString());
jsonObject.addProperty("defectStatus", defect.status == null ? "" : defect.status.toString());
jsonObject.addProperty(
"defectCreated", defect.created == null ? "" : defect.created.toString());
jsonObject.addProperty("defectTags", defect.tags == null ? "" : defect.tags.toString());
jsonObject.addProperty(
"defectDescription", defect.description == null ? "" : defect.description);
renderJSON(jsonObject.toString());
}
@Override
public void update(GameContainer gameContainer, StateBasedGame stateBasedGame, int delta)
throws SlickException {
Input in = gameContainer.getInput();
if (in.isKeyPressed(Input.KEY_C)) {
clear();
}
gameContainer.setMaximumLogicUpdateInterval(updateInterval);
if (in.isMousePressed(Input.MOUSE_LEFT_BUTTON)) {
float x1 = in.getMouseX() / ratio;
float y1 = in.getMouseY() / ratio;
if (start == null) {
start = new Cell((int) x1, (int) y1, ratio, false);
start.start = true;
cells[start.gridPosX][start.gridPosY].start = true;
cellStack.add(cells[start.gridPosX][start.gridPosY]);
} else if (goal == null) {
goal = new Cell((int) x1, (int) y1, ratio, false);
cells[goal.gridPosX][goal.gridPosY].goal = true;
} else {
changeCellAtPosition((int) x1, (int) y1);
}
if (start != null && goal != null) {
this.wall = cells[(int) x1][(int) y1].wall;
}
}
if (in.isMouseButtonDown(Input.MOUSE_LEFT_BUTTON)) {
if (start != null && goal != null) {
mousePressing = true;
float x1 = in.getMouseX() / ratio;
float y1 = in.getMouseY() / ratio;
cells[(int) x1][(int) y1].wall = this.wall;
}
} else {
mousePressing = false;
}
if (in.isKeyPressed(Input.KEY_ENTER)) {
if (mazeSolved && displayingMaze) {
clear();
createGraph();
maze = true;
} else if (!maze) {
this.search = true;
}
}
if (in.isKeyPressed(Input.KEY_M) && !maze) {
createGraph();
maze = true;
this.logger.initWriter();
}
if (in.isKeyPressed(Input.KEY_S)) {
clear();
for (int i = 0; i < cells.length; i++) {
for (int j = 0; j < cells.length; j++) {
Random random = new Random();
if (random.nextInt(3) == 0) {
cells[i][j].wall = true;
}
}
}
setDefaultStartAndEnd(true);
}
if (in.isKeyPressed(Input.KEY_ADD)) {
if (updateInterval > 1) {
updateInterval -= 1;
}
}
if (in.isKeyPressed(Input.KEY_SUBTRACT)) {
if (updateInterval < 20) {
updateInterval += 1;
}
}
if (in.isKeyPressed(Input.KEY_P)) {
if (!gameContainer.isPaused()) {
gameContainer.pause();
} else {
gameContainer.resume();
}
}
if (in.isKeyPressed(Input.KEY_D)) {
this.diagonal = !this.diagonal;
}
if (in.isKeyPressed(Input.KEY_ESCAPE)) {
stateBasedGame.enterState(1);
}
if (in.isKeyPressed(Input.KEY_A)) {
AnalyzeLog.analyzeBacktracks(AnalyzeLog.FIRST);
}
if (in.isKeyPressed(Input.KEY_I)) {
this.createImage();
}
if (this.search) {
if (start == null || goal == null) {
this.search = false;
} else {
if (ButtonStates.DFSState) {
if (solvingVisited.size() < 1) {
solvingVisited.add(cells[start.gridPosX][start.gridPosY]);
cells[start.gridPosX][start.gridPosY].solvingVisited = true;
currentDFSCell = cells[start.gridPosX][start.gridPosY];
} else {
for (int x = 0; x < CELLS; x++) {
for (int y = 0; y < CELLS; y++) {
cells[x][y].dfsCheckNeighbors();
}
}
if (currentDFSCell.goal) {
this.search = false;
this.drawWay = true;
this.end = currentDFSCell;
getPath(false, null);
if (displayingMaze) {
mazeSolved = true;
}
foundSolution = true;
} else {
if (solvingVisited.size() != (CELLS * CELLS)) {
ArrayList<Cell> currentNeighbors = new ArrayList<>();
if (currentDFSCell.dfsNorth != null
&& !currentDFSCell.dfsNorth.solvingVisited
&& !currentDFSCell.dfsNorth.wall) {
currentNeighbors.add(currentDFSCell.dfsNorth);
} else if (currentDFSCell.dfsEast != null
&& !currentDFSCell.dfsEast.solvingVisited
&& !currentDFSCell.dfsEast.wall) {
currentNeighbors.add(currentDFSCell.dfsEast);
} else if (currentDFSCell.dfsSouth != null
&& !currentDFSCell.dfsSouth.solvingVisited
&& !currentDFSCell.dfsSouth.wall) {
currentNeighbors.add(currentDFSCell.dfsSouth);
} else if (currentDFSCell.dfsWest != null
&& !currentDFSCell.dfsWest.solvingVisited
&& !currentDFSCell.dfsWest.wall) {
currentNeighbors.add(currentDFSCell.dfsWest);
} else {;
}
if (currentNeighbors.size() > 0) {
Cell neighbor = currentNeighbors.get(0);
neighbor.solvingPrevious = currentDFSCell;
neighbor.solvingVisited = true;
currentDFSCell = neighbor;
} else {
dfsBacktracked.add(currentDFSCell);
dfsBacktracked.add(currentDFSCell.solvingPrevious);
currentDFSCell = currentDFSCell.solvingPrevious;
}
}
}
}
} else if (ButtonStates.AStarState) {
} else if (ButtonStates.BFSState) {
if (solvingVisited.size() < 1) {
solvingVisited.add(cells[start.gridPosX][start.gridPosY]);
cells[start.gridPosX][start.gridPosY].solvingVisited = true;
cellStack.add(cells[start.gridPosX][start.gridPosY]);
} else {
if (!cellStack.isEmpty()) {
Cell current = (Cell) cellStack.remove();
Cell child;
if (current.goal) {
this.end = current;
this.drawWay = true;
this.search = false;
getPath(false, null);
if (displayingMaze) {
mazeSolved = true;
}
foundSolution = true;
} else {
while ((child = getUnvisitedChildCell(current)) != null) {
child.solvingVisited = true;
child.solvingPrevious = current;
solvingVisited.add(child);
cellStack.add(child);
current.solvingCheckNeighbors(diagonal);
getPath(true, child);
}
}
}
}
} else {
try {
throw new NoSolvingAlgorithmSelectedException();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
if (this.maze) {
if (this.logger.used) {
this.logger.createNewLogFile();
this.logger.initWriter();
this.logger.used = false;
}
if (cells.length != 0) {
logger.writeInLog("Checking neighbors");
for (int i = 0; i < CELLS; i++) {
for (int j = 0; j < CELLS; j++) {
cells[i][j].genCheckNeighbors();
}
}
if (genVisited.size() < 1) {
genVisited.add(cells[1][1]);
currentGenCell = cells[1][1];
currentGenCell.genVisited = true;
logger.writeInLog("Adding Cell X1 and Y1 to visited Cells");
}
if (genVisited.size() != totalCells) {
ArrayList<Cell> currentNeighbors = new ArrayList<>();
if (currentGenCell.north != null
&& !currentGenCell.north.genVisited
&& currentGenCell.north.allWallsIntact) {
currentNeighbors.add(currentGenCell.north);
logger.writeInLog(
"Adding north cell to neighbors at: "
+ currentGenCell.north.gridPosX
+ "; "
+ currentGenCell.north.gridPosY);
}
if (currentGenCell.east != null
&& !currentGenCell.east.genVisited
&& currentGenCell.east.allWallsIntact) {
currentNeighbors.add(currentGenCell.east);
logger.writeInLog(
"Adding east cell to neighbors at: "
+ currentGenCell.east.gridPosX
+ "; "
+ currentGenCell.east.gridPosY);
}
if (currentGenCell.south != null
&& !currentGenCell.south.genVisited
&& currentGenCell.south.allWallsIntact) {
currentNeighbors.add(currentGenCell.south);
logger.writeInLog(
"Adding south cell to neighbors at: "
+ currentGenCell.south.gridPosX
+ "; "
+ currentGenCell.south.gridPosY);
}
if (currentGenCell.west != null
&& !currentGenCell.west.genVisited
&& currentGenCell.west.allWallsIntact) {
currentNeighbors.add(currentGenCell.west);
logger.writeInLog(
"Adding west cell to neighbors at: "
+ currentGenCell.west.gridPosX
+ "; "
+ currentGenCell.west.gridPosY);
}
if (currentNeighbors.size() > 0) {
Random random = new Random();
int randomValue = random.nextInt(currentNeighbors.size());
logger.writeInLog("Generated random number: " + randomValue);
Cell neighbor = currentNeighbors.get(randomValue);
logger.writeInLog("Picked neighbor: " + neighbor.gridPosX + "; " + neighbor.gridPosY);
neighbor.genVisited = true;
int wallX = 0;
int wallY = 0;
// break wall
if (neighbor.gridPosX > currentGenCell.gridPosX) {
wallX = currentGenCell.gridPosX + 1;
} else if (neighbor.gridPosX < currentGenCell.gridPosX) {
wallX = currentGenCell.gridPosX - 1;
} else {
wallX = currentGenCell.gridPosX;
}
if (neighbor.gridPosY > currentGenCell.gridPosY) {
wallY = currentGenCell.gridPosY + 1;
} else if (neighbor.gridPosY < currentGenCell.gridPosY) {
wallY = currentGenCell.gridPosY - 1;
} else {
wallY = currentGenCell.gridPosY;
}
cells[wallX][wallY].wall = false;
cells[wallX][wallY].genVisited = true;
logger.writeInLog("Breaking wall at: " + wallX + "; " + wallY);
genVisited.add(cells[wallX][wallY]);
neighbor.genBacktrack = currentGenCell;
logger.writeInLog(
"Set current cell to backtrack cell at: "
+ currentGenCell.gridPosX
+ "; "
+ currentGenCell.gridPosY);
currentGenCell = neighbor;
} else {
currentGenCell = currentGenCell.genBacktrack;
logger.writeInLog(
"Backtracking at: "
+ currentGenCell.genBacktrack.gridPosX
+ "; "
+ currentGenCell.genBacktrack.gridPosY);
}
} else {
currentGenCell = null;
this.maze = false;
setDefaultStartAndEnd(true);
displayingMaze = true;
if ((this.search = !this.search) == true) {
if (this.startSearch == false) {
this.search = false;
createImage();
}
}
logger.writeInLog("Done Maze, closing logger.");
logger.closeWriter();
if (this.automaticallyGenerateMazes && (generatedMazes < mazesToGenerate)) {
generatedMazes += 1;
clear();
createGraph();
this.maze = true;
} else if (this.logger.stepList.size() != 0) {
this.logger.printStepList();
} else {;
}
}
}
}
char[][] copyOfLevel = new char[CELLS][CELLS];
for (int x = 0; x < cells.length; x++) {
for (int y = 0; y < cells.length; y++) {
if (cells[x][y].wall) {
copyOfLevel[x][y] = 'W';
} else if (!cells[x][y].wall) {
copyOfLevel[x][y] = 'D';
} else if (cells[x][y].start) {
copyOfLevel[x][y] = 'S';
} else if (cells[x][y].goal) {
copyOfLevel[x][y] = 'G';
} else {
copyOfLevel[x][y] = 'D';
}
}
}
Level.update(copyOfLevel);
}
private void dbgMsg(String pMsg) {
Logger.dbg("ArrayListRowFactory" + pMsg);
}
@SuppressWarnings("unchecked")
private Object walk(final Tree node, final DatatypeInfo parent) {
// an optional node that is not present in the current context, is null
if (node == null) {
return null;
}
DatatypeInfo newParent = parent;
CommonTree commonTreeNode = (CommonTree) node;
Tree modifiers;
switch (node.getType()) {
// case CsRewriteRulesParser.ATTRIBUTE:
// System.out.println("ATTRIBUTE");
// break;
case CSharp4AST.NAMESPACE:
CommonTree qid =
(CommonTree) commonTreeNode.getFirstChildWithType(CSharp4AST.QUALIFIED_IDENTIFIER);
Collection<String> namespaces = TreeHelper.treeListToStringList(qid.getChildren());
namespaceStack.addAll(namespaces);
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.NAMESPACE_MEMBER_DECLARATIONS), parent);
for (int i = 0; i < qid.getChildren().size(); i++) namespaceStack.removeLast();
return null;
case CSharp4AST.QUALIFIED_IDENTIFIER:
case CSharp4AST.EXTERN_ALIAS_DIRECTIVES:
case CSharp4AST.USING_DIRECTIVES:
case CSharp4AST.NAMESPACE_MEMBER_DECLARATIONS:
case CSharp4AST.ATTRIBUTES:
case CSharp4AST.CLASS_MEMBER_DECLARATIONS:
case CSharp4AST.INTERFACE_MEMBER_DECLARATIONS:
case CSharp4AST.ENUM_MEMBER_DECLARATIONS:
case CSharp4AST.STRUCT_MEMBER_DECLARATIONS:
case CSharp4AST.CONST:
for (int i = 0; i < commonTreeNode.getChildCount(); i++) {
walk(commonTreeNode.getChild(i), parent);
}
return null;
case CSharp4AST.CLASS:
newParent = new DatatypeInfo("class");
newParent.setNamespace(namespaceStack);
datatypeInfos.add(newParent);
String className =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER),
newParent,
String.class);
newParent.setName(className);
LOGGER.fine("class: " + className);
// modifiers
modifiers = commonTreeNode.getFirstChildWithType(CSharp4AST.MODIFIERS);
if (modifiers != null) {
List<String> modifierNames =
TreeHelper.treeListToStringList(((CommonTree) modifiers).getChildren());
if (modifierNames.contains(ABSTRACT)) {
newParent.setIsAbstract(Boolean.TRUE);
}
}
setFullPath(parent, newParent);
// must be invoked after setFullPath
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.CLASS_MEMBER_DECLARATIONS), newParent);
addToReferences(newParent);
return newParent;
case CSharp4AST.INTERFACE:
newParent = new DatatypeInfo("interface");
newParent.setNamespace(namespaceStack);
datatypeInfos.add(newParent);
String interfaceName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER),
newParent,
String.class);
newParent.setName(interfaceName);
LOGGER.fine("interface: " + interfaceName);
// transform(commonTreeNode.getFirstChildWithType(CSharp4AST.IMPLEMENTS),
// newParent,
// false);
// modifiers
modifiers = commonTreeNode.getFirstChildWithType(CSharp4AST.MODIFIERS);
if (modifiers != null) {
List<String> modifierNames =
TreeHelper.treeListToStringList(((CommonTree) modifiers).getChildren());
if (modifierNames.contains(ABSTRACT)) {
newParent.setIsAbstract(Boolean.TRUE);
}
}
setFullPath(parent, newParent);
// must be invoked after setFullPath
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.INTERFACE_MEMBER_DECLARATIONS),
newParent);
addToReferences(newParent);
return newParent;
case CSharp4AST.ENUM:
newParent = new DatatypeInfo("enum");
newParent.setNamespace(namespaceStack);
datatypeInfos.add(newParent);
String enumName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER),
newParent,
String.class);
newParent.setName(enumName);
LOGGER.fine("enum: " + enumName);
// modifiers
modifiers = commonTreeNode.getFirstChildWithType(CSharp4AST.MODIFIERS);
if (modifiers != null) {
for (int i = 0; i < modifiers.getChildCount(); i++) {
Tree modTree = modifiers.getChild(i);
String modName = modTree.getText();
if (ABSTRACT.equals(modName)) {
newParent.setIsAbstract(Boolean.TRUE);
}
}
}
setFullPath(parent, newParent);
// must be invoked after setFullPath
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.ENUM_MEMBER_DECLARATIONS), newParent);
addToReferences(newParent);
return newParent;
case CSharp4AST.STRUCT:
newParent = new DatatypeInfo("struct");
newParent.setNamespace(namespaceStack);
datatypeInfos.add(newParent);
String structName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER),
newParent,
String.class);
newParent.setName(structName);
// IMPLEMENTS
setFullPath(parent, newParent);
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.STRUCT_MEMBER_DECLARATIONS), newParent);
addToReferences(newParent);
LOGGER.fine("struct: " + newParent);
return newParent;
case CSharp4AST.DELEGATE:
// see http://msdn.microsoft.com/de-de/library/900fyy8e%28v=vs.80%29.aspx
newParent = new DatatypeInfo("delegate");
newParent.setNamespace(namespaceStack);
String delegateName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER),
newParent,
String.class);
newParent.setName(delegateName);
// TODO handle signature and generics
setFullPath(parent, newParent);
addToReferences(newParent);
LOGGER.fine("delegate: " + newParent);
break;
case CSharp4AST.METHOD_DECL:
MethodInfo methodInfo = new MethodInfo(parent);
String returnType =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.TYPE), parent, String.class);
String methodName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.MEMBER_NAME), parent, String.class);
List<ParameterInfo> formalParameters =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.FORMAL_PARAMETER_LIST),
parent,
List.class);
LOGGER.fine("method: " + methodName);
methodInfo.setName(methodName);
methodInfo.setReturnType(returnType);
if (formalParameters != null) methodInfo.getParameters().addAll(formalParameters);
parent.addMethodInfo(methodInfo);
addToReferences(methodInfo);
return methodInfo;
case CSharp4AST.MEMBER_NAME:
String typeName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.NAMESPACE_OR_TYPE_NAME),
parent,
String.class);
return typeName;
case CSharp4AST.FORMAL_PARAMETER_LIST:
List<ParameterInfo> parameters = new LinkedList<ParameterInfo>();
for (int i = 0; i < commonTreeNode.getChildCount(); i++) {
Tree child = commonTreeNode.getChild(i);
ParameterInfo parameter = walk(child, parent, ParameterInfo.class);
parameters.add(parameter);
}
return parameters;
case CSharp4AST.FIXED_PARAMETER:
String fixedParamName =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER), parent, String.class);
String fixedParamType =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.TYPE), parent, String.class);
if (fixedParamType != null) { // if not __arglist
fixedParamType = KeyStringHelper.normalize(fixedParamType);
} else {
fixedParamType = fixedParamName;
}
return new ParameterInfo(fixedParamType, fixedParamName);
case CSharp4AST.PARAMETER_ARRAY:
String paramArrayName =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER), parent, String.class);
String paramArrayType =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.TYPE), parent, String.class);
paramArrayType = KeyStringHelper.normalize(paramArrayType);
return new ParameterInfo(paramArrayType, paramArrayName);
case CSharp4AST.FIELD_DECL:
// do not process children of type TYPE
for (int i = 0; i < commonTreeNode.getChildCount(); i++) {
Tree child = commonTreeNode.getChild(i);
if (child.getType() == CSharp4AST.VARIABLE_DECLARATOR) {
walk(child, parent);
}
}
break;
case CSharp4AST.PROPERTY_DECL:
FieldInfo propertyInfo = new FieldInfo(parent);
String propertyName =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.MEMBER_NAME), parent, String.class);
if (propertyName != null) propertyInfo.setName(propertyName);
String propertyType =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.TYPE), parent, String.class);
propertyInfo.setType(propertyType);
parent.addFieldInfo(propertyInfo);
addToReferences(propertyInfo);
LOGGER.fine("LOAD PROPERTY: " + propertyInfo.getName());
return propertyInfo;
case CSharp4AST.VARIABLE_DECLARATOR:
FieldInfo fieldInfo = new FieldInfo(parent);
String fieldName =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER), parent, String.class);
if (fieldName != null) fieldInfo.setName(fieldName);
String variableType =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.TYPE), parent, String.class);
fieldInfo.setType(variableType);
parent.addFieldInfo(fieldInfo);
addToReferences(fieldInfo);
return fieldInfo;
case CSharp4AST.ENUM_MEMBER_DECLARATION:
LOGGER.warning("UNSUPPORTED: enum member declarations are not yet supported.");
break;
case CSharp4AST.TYPE:
StringBuilder builder = new StringBuilder();
Tree baseTypeNode = commonTreeNode.getChild(0);
switch (baseTypeNode.getType()) {
case CSharp4AST.NAMESPACE_OR_TYPE_NAME:
String qualifiedBaseType = walk(baseTypeNode, parent, String.class);
builder.append(qualifiedBaseType);
break;
default: // OBJECT, STRING, VOID, IDENTIFIER(dynamic), and primitive
// types
builder.append(baseTypeNode.getText());
break;
}
for (int i = 1; i < commonTreeNode.getChildCount(); i++) {
Tree typeExtension = commonTreeNode.getChild(i);
// INTERR, rank_specifier, STAR
switch (typeExtension.getType()) {
case CSharp4AST.INTERR:
LOGGER.warning("UNSUPPORTED: INTERR is not yet supported");
break;
case CSharp4AST.RANK_SPECIFIER:
builder.append("[");
int numCommas = typeExtension.getChildCount();
do {
builder.append(",");
} while (numCommas-- > 0);
builder.append("]");
break;
case CSharp4AST.STAR:
builder.append("*");
break;
default:
break;
}
}
return builder.toString();
case CSharp4AST.NAMESPACE_OR_TYPE_NAME:
builder = new StringBuilder();
String nsIdentifier =
walk(commonTreeNode.getFirstChildWithType(CSharp4AST.IDENTIFIER), parent, String.class);
if (nsIdentifier != null) builder.append(nsIdentifier);
List<String> qualified_alias_member =
walk(
commonTreeNode.getFirstChildWithType(CSharp4AST.QUALIFIED_ALIAS_MEMBER),
parent,
List.class);
if (qualified_alias_member != null) {
for (String qam : qualified_alias_member) {
builder.append(".");
builder.append(qam);
}
}
for (int i = 1; i < node.getChildCount(); i++) {
CommonTree child = (CommonTree) node.getChild(i);
if (child.getType() == CSharp4AST.NAMESPACE_OR_TYPE_PART) {
String nsPart =
walk(child.getFirstChildWithType(CSharp4AST.IDENTIFIER), parent, String.class);
builder.append(".");
builder.append(nsPart);
}
}
return builder.toString();
case CSharp4AST.IDENTIFIER:
return node.getText();
default:
return null;
}
return null;
}