/** Populate current module fields with data from dependent modules. */
protected void initDependencies() { // Reduce iterators over dependencies for
// compilation issue with lazy loading
for (CompiledDependency dependency : this.getDependencies()) {
// commented as there is no need to add each datatype to upper
// module.
// as now it`s will be impossible to validate from which module the
// datatype is.
//
// addTypes(dependency);
addDependencyTypes(dependency);
addMethods(dependency);
// Populate current module fields with data from dependent modules.
// Requered
// for data tables inheriting from dependend modules.
addDataTables(dependency.getCompiledOpenClass()); // Required for
// data tables.
}
}
protected void addTestSuiteMethodsFromDependencies() {
for (CompiledDependency dependency : this.getDependencies()) {
for (IOpenMethod depMethod :
dependency.getCompiledOpenClass().getOpenClassWithErrors().getMethods()) {
if (depMethod instanceof TestSuiteMethod) {
TestSuiteMethod testSuiteMethod = (TestSuiteMethod) depMethod;
try {
// Workaround for set dependency names in method while
// compile
if (testSuiteMethod.getModuleName() == null) {
testSuiteMethod.setModuleName(dependency.getDependencyName());
}
TestSuiteMethod newTestSuiteMethod = createNewTestSuiteMethod(testSuiteMethod);
addMethod(newTestSuiteMethod);
} catch (OpenlNotCheckedException e) {
if (Log.isDebugEnabled()) {
Log.debug(e.getMessage(), e);
}
addError(e);
}
}
}
}
}
@Override
public void addError(Throwable error) {
if (error instanceof DuplicatedMethodException
|| error instanceof DuplicatedVarException
|| error instanceof DuplicatedTableException
|| error instanceof SyntaxNodeException) {
if (VirtualSourceCodeModule.SOURCE_URI.equals(metaInfo.getSourceUrl())) {
// Avoid duplication of error messages. This error was defined
// in dependent module already.
for (CompiledDependency dependency : getDependencies()) {
List<OpenLMessage> errors =
OpenLMessagesUtils.filterMessagesBySeverity(
dependency.getCompiledOpenClass().getMessages(), Severity.ERROR);
for (OpenLMessage message : errors) {
if (message.getSummary() != null && message.getSummary().equals(error.getMessage())) {
return;
}
}
}
}
}
super.addError(error);
}
private void addDataTables(CompiledOpenClass dependency) {
IOpenClass openClass = dependency.getOpenClassWithErrors();
Map<String, IOpenField> fieldsMap = openClass.getFields();
Set<String> tableUrls = new HashSet<String>();
Map<String, IOpenField> fields = getFields();
for (IOpenField openField : fields.values()) {
if (openField instanceof DataOpenField) {
tableUrls.add(((DataOpenField) openField).getTableUri());
}
}
for (String key : fieldsMap.keySet()) {
IOpenField field = fieldsMap.get(key);
if (field instanceof DataOpenField) {
DataOpenField dataOpenField = (DataOpenField) field;
try {
String tableUrl = dataOpenField.getTableUri();
// Test tables are added both as methods and variables.
if (!tableUrls.contains(tableUrl) && !duplicatedMethodUrls.contains(tableUrl)) {
boolean containsInDependency = false;
if (VirtualSourceCodeModule.SOURCE_URI.equals(metaInfo.getSourceUrl())) {
for (CompiledDependency d : getDependencies()) {
IOpenClass dependentModuleClass = d.getCompiledOpenClass().getOpenClassWithErrors();
if (dependentModuleClass instanceof XlsModuleOpenClass) {
if (((XlsModuleOpenClass) dependentModuleClass)
.duplicatedMethodUrls.contains(tableUrl)) {
containsInDependency = true;
break;
}
}
}
}
if (!containsInDependency) {
addField(field);
tableUrls.add(tableUrl);
}
}
} catch (OpenlNotCheckedException e) {
SyntaxNodeException error =
SyntaxNodeExceptionUtils.createError(
e.getMessage(), e, dataOpenField.getTable().getTableSyntaxNode());
addError(error);
}
}
}
if (openClass instanceof XlsModuleOpenClass) {
XlsModuleOpenClass xlsModuleOpenClass = (XlsModuleOpenClass) openClass;
if (xlsModuleOpenClass.getDataBase() != null) {
for (ITable table : xlsModuleOpenClass.getDataBase().getTables()) {
if (XlsNodeTypes.XLS_DATA.toString().equals(table.getTableSyntaxNode().getType())) {
try {
getDataBase().registerTable(table);
} catch (DuplicatedTableException e) {
addError(e);
} catch (OpenlNotCheckedException e) {
addError(e);
}
}
}
}
}
}