/******************************************************************************** | |
* Copyright (c) 2015-2018 Contributors to the Eclipse Foundation | |
* | |
* See the NOTICE file(s) distributed with this work for additional | |
* information regarding copyright ownership. | |
* | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v. 2.0 which is available at | |
* http://www.eclipse.org/legal/epl-2.0. | |
* | |
* SPDX-License-Identifier: EPL-2.0 | |
* | |
********************************************************************************/ | |
package org.eclipse.mdm.api.atfxadapter; | |
import java.util.Locale; | |
import org.eclipse.mdm.api.base.adapter.EntityType; | |
import org.eclipse.mdm.api.base.adapter.Relation; | |
import org.eclipse.mdm.api.base.model.Channel; | |
import org.eclipse.mdm.api.base.model.ChannelGroup; | |
import org.eclipse.mdm.api.base.model.ContextComponent; | |
import org.eclipse.mdm.api.base.model.ContextRoot; | |
import org.eclipse.mdm.api.base.model.ContextSensor; | |
import org.eclipse.mdm.api.base.model.ContextType; | |
import org.eclipse.mdm.api.base.model.Entity; | |
import org.eclipse.mdm.api.base.model.Environment; | |
import org.eclipse.mdm.api.base.model.Measurement; | |
import org.eclipse.mdm.api.base.model.Parameter; | |
import org.eclipse.mdm.api.base.model.ParameterSet; | |
import org.eclipse.mdm.api.base.model.PhysicalDimension; | |
import org.eclipse.mdm.api.base.model.Quantity; | |
import org.eclipse.mdm.api.base.model.Sortable; | |
import org.eclipse.mdm.api.base.model.Test; | |
import org.eclipse.mdm.api.base.model.TestStep; | |
import org.eclipse.mdm.api.base.model.Unit; | |
import org.eclipse.mdm.api.base.model.User; | |
import org.eclipse.mdm.api.dflt.model.Pool; | |
import org.eclipse.mdm.api.dflt.model.Project; | |
import org.eclipse.mdm.api.odsadapter.lookup.config.DefaultEntityConfigRepositoryLoader; | |
import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfig; | |
import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfig.Key; | |
import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfigRepository; | |
import org.eclipse.mdm.api.odsadapter.lookup.config.EntityConfigRepositoryLoader; | |
import org.eclipse.mdm.api.odsadapter.query.ODSEntityType; | |
import org.eclipse.mdm.api.odsadapter.query.ODSModelManager; | |
import org.eclipse.mdm.api.odsadapter.utils.ODSUtils; | |
import org.slf4j.Logger; | |
import org.slf4j.LoggerFactory; | |
public class ATFXEntityConfigRepositoryLoader implements EntityConfigRepositoryLoader { | |
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultEntityConfigRepositoryLoader.class); | |
EntityConfigRepository entityConfigRepository; | |
public ATFXEntityConfigRepositoryLoader() { | |
} | |
/** | |
* Loads the {@link EntityConfig}s. | |
* @return | |
*/ | |
@Override | |
public EntityConfigRepository loadEntityConfigurations(ODSModelManager modelManager) { | |
LOGGER.debug("Loading entity configurations..."); | |
long start = System.currentTimeMillis(); | |
entityConfigRepository = new EntityConfigRepository(); | |
// Environment | Project | Pool | PhysicalDimension | User | Measurement | |
// | ChannelGroup | |
entityConfigRepository.register(create(modelManager, new Key<>(Environment.class), "Environment", false)); | |
entityConfigRepository.register(create(modelManager, new Key<>(Project.class), "Project", false)); | |
entityConfigRepository.register(create(modelManager, new Key<>(Pool.class), "StructureLevel", true)); | |
entityConfigRepository.register(create(modelManager, new Key<>(PhysicalDimension.class), "PhysDimension", false)); | |
entityConfigRepository.register(create(modelManager, new Key<>(Measurement.class), "MeaResult", false)); | |
entityConfigRepository.register(create(modelManager, new Key<>(ChannelGroup.class), "SubMatrix", false)); | |
// Unit | |
EntityConfig<Unit> unitConfig = create(modelManager, new Key<>(Unit.class), "Unit", false); | |
unitConfig.addMandatory(entityConfigRepository.findRoot(new Key<>(PhysicalDimension.class))); | |
entityConfigRepository.register(unitConfig); | |
// Quantity | |
EntityConfig<Quantity> quantityConfig = create(modelManager, new Key<>(Quantity.class), "Quantity", false); | |
quantityConfig.addMandatory(entityConfigRepository.findRoot(new Key<>(Unit.class))); | |
entityConfigRepository.register(quantityConfig); | |
// Channel | |
EntityConfig<Channel> channelConfig = create(modelManager, new Key<>(Channel.class), "MeaQuantity", false); | |
channelConfig.addMandatory(entityConfigRepository.findRoot(new Key<>(Unit.class))); | |
channelConfig.addMandatory(entityConfigRepository.findRoot(new Key<>(Quantity.class))); | |
entityConfigRepository.register(channelConfig); | |
// ParameterSet | |
EntityConfig<Parameter> parameterConfig = create(modelManager, new Key<>(Parameter.class), "ResultParameter", true); | |
parameterConfig.addOptional(entityConfigRepository.findRoot(new Key<>(Unit.class))); | |
EntityConfig<ParameterSet> parameterSetConfig = create(modelManager, new Key<>(ParameterSet.class), "ResultParameterSet", true); | |
parameterSetConfig.addChild(parameterConfig); | |
entityConfigRepository.register(parameterSetConfig); | |
// TestStep | |
EntityConfig<TestStep> testStepConfig = create(modelManager, new Key<>(TestStep.class), "TestStep", true); | |
testStepConfig.setComparator(Sortable.COMPARATOR); | |
entityConfigRepository.register(testStepConfig); | |
// Test | |
EntityConfig<Test> testConfig = create(modelManager, new Key<>(Test.class), "Test", true); | |
entityConfigRepository.register(testConfig); | |
// ContextRoots | |
registerContextRoot(modelManager, ContextType.UNITUNDERTEST); | |
registerContextRoot(modelManager, ContextType.TESTSEQUENCE); | |
registerContextRoot(modelManager, ContextType.TESTEQUIPMENT); | |
LOGGER.debug("Entity configurations loaded in {} ms.", System.currentTimeMillis() - start); | |
return entityConfigRepository; | |
} | |
/** | |
* Loads the {@link EntityConfig}s required for {@link ContextRoot} with | |
* given {@link ContextType}. | |
* | |
* @param contextType | |
* The {@code ContextType}. | |
*/ | |
private void registerContextRoot(ODSModelManager modelManager, ContextType contextType) { | |
EntityConfig<ContextRoot> contextRootConfig = create(modelManager, new Key<>(ContextRoot.class, contextType), | |
ODSUtils.CONTEXTTYPES.get(contextType), true); | |
for (Relation contextComponentRelation : contextRootConfig.getEntityType().getChildRelations()) { | |
EntityType contextComponentEntityType = contextComponentRelation.getTarget(); | |
EntityConfig<ContextComponent> contextComponentConfig = create(modelManager, | |
new Key<>(ContextComponent.class, contextType), contextComponentEntityType.getName(), true); | |
contextRootConfig.addChild(contextComponentConfig); | |
if (contextType.isTestEquipment()) { | |
for (Relation contextSensorRelation : contextComponentEntityType.getChildRelations()) { | |
EntityType contextSensorEntityType = contextSensorRelation.getTarget(); | |
EntityConfig<ContextSensor> contextSensorConfig = create(modelManager, new Key<>(ContextSensor.class), | |
contextSensorEntityType.getName(), true); | |
contextComponentConfig.addChild(contextSensorConfig); | |
} | |
} | |
} | |
entityConfigRepository.register(contextRootConfig); | |
} | |
/** | |
* Creates a new {@link EntityConfig}. | |
* | |
* @param <T> | |
* The entity type. | |
* @param key | |
* Used as identifier. | |
* @param typeName | |
* Name of the associated {@link EntityType}. | |
* @param appendName | |
* Flag indicates whether to append the entity types base name to | |
* the MIME type. | |
* @return The created {@code EntityConfig} is returned. | |
*/ | |
private <T extends Entity> EntityConfig<T> create(ODSModelManager modelManager, Key<T> key, String typeName, boolean appendName) { | |
EntityConfig<T> entityConfig = new EntityConfig<>(key); | |
ODSEntityType entityType = (ODSEntityType) modelManager.getEntityType(typeName); | |
entityConfig.setEntityType(entityType); | |
entityConfig.setMimeType(buildDefaultMimeType(entityType, appendName)); | |
return entityConfig; | |
} | |
/** | |
* Creates a default MIME type for given {@link EntityType}. | |
* | |
* @param entityType | |
* The {@code EntityType}. | |
* @param appendName | |
* Flag indicates whether to append the entity types base name to | |
* the MIME type. | |
* @return The created MIME type {@code String} is returned. | |
*/ | |
private String buildDefaultMimeType(ODSEntityType entityType, boolean appendName) { | |
StringBuilder sb = new StringBuilder(); | |
sb.append("application/x-asam."); | |
sb.append(entityType.getBaseName().toLowerCase(Locale.ROOT)); | |
if (appendName) { | |
sb.append('.').append(entityType.getName().toLowerCase(Locale.ROOT)); | |
} | |
return sb.toString(); | |
} | |
} |