@Override
public boolean hasChildren(Object element) {
if (element instanceof FSTClass) {
for (FSTRole role : ((FSTClass) element).getRoles()) {
if (!role.getClassFragment().getMethods().isEmpty()
|| !role.getClassFragment().getFields().isEmpty()
|| !role.getDirectives().isEmpty()
|| !role.getInnerClasses().isEmpty()) {
return true;
}
}
return false;
}
if (element instanceof FSTMethod) {
FSTMethod fstMethod = (FSTMethod) element;
FSTRole role = fstMethod.getRole();
return role.getMethods().contains(element) || !fstMethod.getFSTDirectives().isEmpty();
}
if (element instanceof FSTField) return false;
if (element instanceof FSTInvariant) return true;
if (element instanceof FSTDirective) {
return ((FSTDirective) element).getRoleElementChildren().length != 0;
}
if (element instanceof FSTClassFragment) {
FSTClassFragment innerClass = (FSTClassFragment) element;
if (!innerClass.getMethods().isEmpty()
|| !innerClass.getFields().isEmpty()
|| !innerClass.getInnerClasses().isEmpty()) {
return true;
}
}
return false;
}
@Override
public Object[] getChildren(Object parentElement) {
Object[] obj = null;
if (parentElement instanceof FSTClass) {
// get all fields, methods, directives and invariants
final TreeSet<FSTMethod> methods = new TreeSet<FSTMethod>();
final TreeSet<FSTField> fields = new TreeSet<FSTField>();
final TreeSet<FSTInvariant> invariants = new TreeSet<FSTInvariant>();
final TreeSet<FSTDirective> directives = new TreeSet<FSTDirective>();
final TreeSet<FSTClassFragment> innerClasses = new TreeSet<FSTClassFragment>();
for (FSTRole role : ((FSTClass) parentElement).getRoles()) {
invariants.addAll(role.getClassFragment().getInvariants());
for (FSTMethod fstMethod : role.getMethods()) {
if (fstMethod.getParent() instanceof FSTClassFragment) methods.add(fstMethod);
}
fields.addAll(role.getFields());
TreeSet<FSTDirective> roleDirectives = role.getDirectives();
for (FSTDirective directive : roleDirectives) {
if (directive.getParent() == null) {
directives.add(directive);
}
}
innerClasses.addAll(role.getInnerClasses());
}
obj =
new IRoleElement
[methods.size()
+ fields.size()
+ invariants.size()
+ directives.size()
+ innerClasses.size()];
int pos = 0;
System.arraycopy(invariants.toArray(), 0, obj, pos, invariants.size());
System.arraycopy(fields.toArray(), 0, obj, pos += invariants.size(), fields.size());
System.arraycopy(methods.toArray(), 0, obj, pos += fields.size(), methods.size());
System.arraycopy(directives.toArray(), 0, obj, pos += methods.size(), directives.size());
System.arraycopy(
innerClasses.toArray(), 0, obj, pos += directives.size(), innerClasses.size());
return filter(obj);
} else if (parentElement instanceof FSTMethod) {
// get all the roles that belong to a method
Set<FSTRole> roleList = new HashSet<FSTRole>();
Set<FSTMethod> methods = new HashSet<FSTMethod>();
for (FSTRole role : ((FSTMethod) parentElement).getRole().getFSTClass().getRoles()) {
for (FSTMethod m : role.getAllMethods()) {
if ( // m.isOwn(role.file) &&
// ((FSTMethod)parentElement).isOwn(role.file) &&
m.getFullName().equals(((FSTMethod) parentElement).getFullName())) {
if (m.hasContract()) {
roleList.add(
new FSTContractedRole(role.getFile(), role.getFeature(), role.getFSTClass()));
} else {
roleList.add(role);
}
methods.add(m);
break;
}
}
}
List<String> featureOrder =
CorePlugin.getFeatureProject(((FSTMethod) parentElement).getRole().getFile())
.getFeatureModel()
.getFeatureOrderList();
if (((FSTMethod) parentElement).getFSTDirectives().size() == 0) {
obj = new FSTRole[roleList.size()];
int index = 0;
for (String featureName : featureOrder) {
for (Iterator<FSTRole> it = roleList.iterator(); it.hasNext(); ) {
FSTRole next = it.next();
if (next.getFeature().getName().equals(featureName)) {
obj[index++] = next;
it.remove();
break;
}
}
}
} else {
List<FSTDirective> dirs = new ArrayList<>();
for (FSTRole role : roleList) {
if (role.getMethods().contains(parentElement)) {
// equals works correct?
for (FSTMethod method : role.getMethods()) {
if (method.equals(parentElement)) {
dirs.addAll(method.getFSTDirectives());
break;
}
}
}
}
return dirs.toArray();
}
} else if (parentElement instanceof FSTInvariant) {
// get all the roles that belong to an invariant
LinkedList<FSTRole> roleList = new LinkedList<FSTRole>();
for (FSTRole role : ((FSTInvariant) parentElement).getRole().getFSTClass().getRoles()) {
for (FSTInvariant i : role.getClassFragment().getInvariants()) {
if (((FSTInvariant) parentElement).getFullName().equals(i.getFullName())) {
roleList.add(role);
break;
}
}
}
return filter(roleList.toArray());
} else if (parentElement instanceof FSTField) {
// get all the roles that belong to a field
LinkedList<FSTRole> roleList = new LinkedList<FSTRole>();
for (FSTRole role : ((FSTField) parentElement).getRole().getFSTClass().getRoles()) {
for (FSTField f : role.getAllFields()) {
if (f.getFullName().equals(((FSTField) parentElement).getFullName())) {
roleList.add(role);
break;
}
}
}
return filter(roleList.toArray());
} else if (parentElement instanceof FSTDirective) {
return ((FSTDirective) parentElement).getRoleElementChildren();
} else if (parentElement instanceof FSTClassFragment) {
final TreeSet<FSTMethod> methods = new TreeSet<FSTMethod>();
final TreeSet<FSTField> fields = new TreeSet<FSTField>();
final TreeSet<FSTClassFragment> innerClasses = new TreeSet<FSTClassFragment>();
final TreeSet<FSTInvariant> invariants = new TreeSet<FSTInvariant>();
FSTClassFragment innerClassCast = (FSTClassFragment) parentElement;
invariants.addAll(innerClassCast.getInvariants());
LinkedList<FSTClassFragment> allFragments =
innerClassCast.getRole().getAllEqualFSTFragments(innerClassCast);
for (FSTClassFragment fstClassFragment : allFragments) {
methods.addAll(fstClassFragment.getMethods());
fields.addAll(fstClassFragment.getFields());
}
innerClasses.addAll(innerClassCast.getInnerClasses());
obj =
new IRoleElement
[methods.size() + fields.size() + invariants.size() + innerClasses.size()];
int pos = 0;
System.arraycopy(invariants.toArray(), 0, obj, pos, invariants.size());
System.arraycopy(fields.toArray(), 0, obj, pos += invariants.size(), fields.size());
System.arraycopy(methods.toArray(), 0, obj, pos += fields.size(), methods.size());
System.arraycopy(innerClasses.toArray(), 0, obj, pos += methods.size(), innerClasses.size());
}
return filter(obj);
}
/**
* Propagates all markers of the given file
*
* @param markers
* @param file
*/
private void propagateMarkers(AbstractCollection<IMarker> markers, IFile file) {
if (!file.exists()) {
return;
}
String content = getFileContent(file);
LinkedList<FSTField> fields = new LinkedList<FSTField>();
LinkedList<FSTMethod> methods = new LinkedList<FSTMethod>();
IFeatureProject project = CorePlugin.getFeatureProject(file);
if (project == null) {
return;
}
FSTModel model = project.getFSTModel();
if (model == null) {
return;
}
for (FSTFeature f : model.getFeaturesMap().values()) {
TreeMap<String, FSTClass> z = f.getClasses();
String fileName = file.getName();
if (z.containsKey(fileName)) {
FSTClass c = z.get(fileName);
for (FSTField field : c.getFields()) {
fields.add(field);
}
for (FSTMethod method : c.getMethods()) {
methods.add(method);
}
}
}
setElementLines(content, fields, methods);
for (IMarker marker : markers) {
if (!marker.exists()) {
continue;
}
if (marker.getAttribute(IMarker.MESSAGE, "").startsWith("The import")) {
propagateUnsupportedMarker(marker, file);
continue;
}
int markerLine = marker.getAttribute(IMarker.LINE_NUMBER, -1);
if (markerLine == -1) {
continue;
}
boolean propagated = false;
for (FSTField f : fields) {
if (f.getEndLine() == -1) {
continue;
}
int composedLine = f.getComposedLine();
if (markerLine >= composedLine
&& markerLine <= composedLine + (f.getEndLine() - f.getBeginLine())) {
propagateMarker(marker, f.getOwnFile(), f.getBeginLine() + markerLine - composedLine);
propagated = true;
break;
}
}
if (propagated) {
continue;
}
for (FSTMethod m : methods) {
if (m.getEndLine() == -1) {
continue;
}
int composedLine = m.getComposedLine();
if (markerLine >= composedLine
&& markerLine <= composedLine + (m.getEndLine() - m.getBeginLine())) {
propagateMarker(
marker, m.getOwnFile(), m.getBeginLine() + markerLine - m.getComposedLine());
propagated = true;
break;
}
}
if (propagated) {
continue;
}
propagateUnsupportedMarker(marker, file);
}
}