Examples with Alignment eu.esdihumboldt.hale.common.align.model.Alignment used on opensource projects

Example 16 with Alignment

use of eu.esdihumboldt.hale.common.align.model.Alignment in project hale by halestudio.

the class AbstractBaseAlignmentLoader method migrateCells.

private List<MutableCell> migrateCells(List<MutableCell> cells, SimpleLog log) {
    List<MutableCell> result = new ArrayList<>();
    // Collect mappings from all UnmigratedCells
    Map<EntityDefinition, EntityDefinition> allMappings = new HashMap<>();
    cells.stream().filter(c -> c instanceof UnmigratedCell).map(c -> (UnmigratedCell) c).forEach(uc -> allMappings.putAll(uc.getEntityMappings()));
    // Add cells to the alignment, migrate UnmigratedCells
    for (MutableCell cell : cells) {
        if (cell instanceof UnmigratedCell) {
            result.add(((UnmigratedCell) cell).migrate(allMappings, log));
        } else {
            result.add(cell);
        }
    }
    return result;
}

Example 17 with Alignment

use of eu.esdihumboldt.hale.common.align.model.Alignment in project hale by halestudio.

the class InlineTransformation method evaluate.

@Override
protected Object evaluate(String transformationIdentifier, TransformationEngine engine, ListMultimap<String, PropertyValue> variables, String resultName, PropertyEntityDefinition resultProperty, Map<String, String> executionParameters, TransformationLog log) throws TransformationException, NoResultException {
    List<PropertyValue> sources = variables.get(null);
    if (sources.isEmpty()) {
        throw new NoResultException("No source available to transform");
    }
    PropertyValue source = sources.get(0);
    Object sourceValue = source.getValue();
    if (sourceValue == null) {
        throw new NoResultException("Source value is null");
    }
    if (!(sourceValue instanceof Instance)) {
        throw new TransformationException("Sources for inline transformation must be instances");
    }
    Instance sourceInstance = (Instance) sourceValue;
    TypeDefinition sourceType = sourceInstance.getDefinition();
    // get the original alignment
    Alignment orgAlignment = getExecutionContext().getAlignment();
    MutableAlignment alignment = new DefaultAlignment(orgAlignment);
    // identify relevant type cell(s)
    MutableCell queryCell = new DefaultCell();
    ListMultimap<String, Type> sourceEntities = ArrayListMultimap.create();
    sourceEntities.put(null, new DefaultType(new TypeEntityDefinition(sourceType, SchemaSpaceID.SOURCE, null)));
    queryCell.setSource(sourceEntities);
    ListMultimap<String, Type> targetEntities = ArrayListMultimap.create();
    targetEntities.put(null, new DefaultType(new TypeEntityDefinition(resultProperty.getDefinition().getPropertyType(), SchemaSpaceID.TARGET, null)));
    queryCell.setTarget(targetEntities);
    Collection<? extends Cell> candidates = alignment.getTypeCells(queryCell);
    if (candidates.isEmpty()) {
        log.error(log.createMessage("No type transformations found for inline transformation", null));
        throw new NoResultException();
    }
    // filter alignment -> only keep relevant type relations
    List<Cell> allTypeCells = new ArrayList<>(alignment.getTypeCells());
    for (Cell cell : allTypeCells) {
        // remove cell
        alignment.removeCell(cell);
        if (!cell.getTransformationMode().equals(TransformationMode.disabled)) {
            // only readd if not disabled
            MutableCell copy = new DefaultCell(cell);
            if (candidates.contains(cell)) {
                // readd as active
                copy.setTransformationMode(TransformationMode.active);
            } else {
                // readd as passive
                copy.setTransformationMode(TransformationMode.passive);
            }
            alignment.addCell(copy);
        }
    }
    // prepare transformation input/output
    DefaultInstanceCollection sourceInstances = new DefaultInstanceCollection();
    sourceInstances.add(sourceInstance);
    DefaultInstanceSink target = new DefaultInstanceSink();
    // run transformation
    TransformationService ts = getExecutionContext().getService(TransformationService.class);
    if (ts == null) {
        throw new TransformationException("Transformation service not available for inline transformation");
    }
    ProgressIndicator progressIndicator = new LogProgressIndicator();
    TransformationReport report = ts.transform(alignment, sourceInstances, new ThreadSafeInstanceSink<InstanceSink>(target), getExecutionContext(), progressIndicator);
    // copy report messages
    log.importMessages(report);
    if (!report.isSuccess()) {
        // copy report messages
        log.importMessages(report);
        throw new TransformationException("Inline transformation failed");
    }
    // extract result
    List<Instance> targetList = target.getInstances();
    if (targetList.isEmpty()) {
        log.error(log.createMessage("Inline transformation yielded no result", null));
        throw new NoResultException("No result from inline transformation");
    }
    if (targetList.size() > 1) {
        log.error(log.createMessage("Inline transformation yielded multiple results, only first result is used", null));
    }
    return targetList.get(0);
}

Example 18 with Alignment

use of eu.esdihumboldt.hale.common.align.model.Alignment in project hale by halestudio.

the class SchemaExplorerLabelProvider method getBackground.

/**
 * @see IColorProvider#getBackground(Object)
 */
@Override
public Color getBackground(Object element) {
    if (element instanceof EntityDefinition) {
        AlignmentService as = PlatformUI.getWorkbench().getService(AlignmentService.class);
        Alignment alignment = as.getAlignment();
        EntityDefinition entityDef = (EntityDefinition) element;
        return getEntityBackground(entityDef, alignment, entityDef.getPropertyPath().isEmpty());
    }
    return null;
}

Example 19 with Alignment

use of eu.esdihumboldt.hale.common.align.model.Alignment in project hale by halestudio.

the class TransformationView method update.

/**
 * Set the current alignment
 */
private void update() {
    final Display display = PlatformUI.getWorkbench().getDisplay();
    // TODO add configuration option if instances should be included?
    display.syncExec(new Runnable() {

        @Override
        public void run() {
            AlignmentService as = PlatformUI.getWorkbench().getService(AlignmentService.class);
            Alignment alignment = as.getAlignment();
            InstanceSampleService iss = PlatformUI.getWorkbench().getService(InstanceSampleService.class);
            Collection<Instance> instances = iss.getReferenceInstances();
            if (instanceAction.isChecked()) {
                if (instances != null && !instances.isEmpty()) {
                    instances = new ArrayList<Instance>(instances);
                    // alignment paired with instances as input
                    getViewer().setInput(new Pair<Object, Object>(alignment, instances));
                } else {
                    getViewer().setInput(null);
                }
            } else {
                // only the alignment as input
                getViewer().setInput(alignment);
            }
            getViewer().applyLayout();
        }
    });
}

Example 20 with Alignment

use of eu.esdihumboldt.hale.common.align.model.Alignment in project hale by halestudio.

the class AlignmentServiceUndoSupport method clean.

/**
 * @see AlignmentServiceDecorator#clean()
 */
@Override
public synchronized void clean() {
    // XXX problem: what about cleans that should not be undone? e.g. when
    // the schemas have changed
    // XXX -> currently on project clean the workbench history is reset
    Alignment alignment = getAlignment();
    if (alignment.getCells().isEmpty()) {
        return;
    }
    if (alignment instanceof MutableAlignment) {
        /*
			 * As long as there is no copy constructor in DefaultAlignment, undo
			 * only supported if the current alignment is a MutableAlignment.
			 */
        IUndoableOperation operation = new CleanOperation((MutableAlignment) alignment);
        executeOperation(operation);
    } else {
        super.clean();
    }
}