| /******************************************************************************** |
| * Copyright (c) 2015-2020 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.apicopy.control; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.time.LocalDateTime; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Optional; |
| import java.util.Set; |
| import java.util.stream.Collectors; |
| |
| import org.apache.commons.lang3.ArrayUtils; |
| import org.eclipse.mdm.api.base.ServiceNotProvidedException; |
| import org.eclipse.mdm.api.base.Transaction; |
| import org.eclipse.mdm.api.base.adapter.ModelManager; |
| import org.eclipse.mdm.api.base.file.FileService; |
| import org.eclipse.mdm.api.base.massdata.AnyTypeValuesBuilder; |
| import org.eclipse.mdm.api.base.massdata.ComplexNumericalValuesBuilder; |
| import org.eclipse.mdm.api.base.massdata.ExternalComponent; |
| import org.eclipse.mdm.api.base.massdata.NumericalValuesBuilder; |
| import org.eclipse.mdm.api.base.massdata.WriteRequest; |
| import org.eclipse.mdm.api.base.massdata.WriteRequestBuilder; |
| import org.eclipse.mdm.api.base.model.Channel; |
| import org.eclipse.mdm.api.base.model.ChannelGroup; |
| import org.eclipse.mdm.api.base.model.DoubleComplex; |
| import org.eclipse.mdm.api.base.model.Entity; |
| import org.eclipse.mdm.api.base.model.FileLink; |
| import org.eclipse.mdm.api.base.model.FloatComplex; |
| import org.eclipse.mdm.api.base.model.MeasuredValues; |
| import org.eclipse.mdm.api.base.model.MeasuredValues.ValueIterator; |
| import org.eclipse.mdm.api.base.model.Measurement; |
| import org.eclipse.mdm.api.base.model.Quantity; |
| import org.eclipse.mdm.api.base.model.ScalarType; |
| import org.eclipse.mdm.api.base.model.SequenceRepresentation; |
| 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.Value; |
| import org.eclipse.mdm.api.base.model.ValueType; |
| import org.eclipse.mdm.api.base.query.Filter; |
| import org.eclipse.mdm.api.base.search.SearchService; |
| import org.eclipse.mdm.api.dflt.ApplicationContext; |
| import org.eclipse.mdm.api.dflt.EntityManager; |
| import org.eclipse.mdm.api.dflt.model.EntityFactory; |
| import org.eclipse.mdm.api.dflt.model.Pool; |
| import org.eclipse.mdm.api.dflt.model.Project; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.google.common.base.Strings; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.LinkedListMultimap; |
| import com.google.common.collect.ListMultimap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Multimap; |
| import com.google.common.io.Files; |
| |
| public abstract class TransferBase { |
| private static final Logger LOG = LoggerFactory.getLogger(TransferBase.class); |
| |
| List<Class<? extends Entity>> supportedRootEntities = Arrays.asList(Project.class, Pool.class, Test.class, |
| TestStep.class, Measurement.class); |
| |
| ApplicationContext contextSrc; |
| EntityManager entityManagerSrc; |
| |
| ApplicationContext contextDst; |
| EntityManager entityManagerDst; |
| EntityFactory entityFactoryDst; |
| ModelManager modelManagerDst; |
| FileService fileServiceDst; |
| FileService fileServiceSrc; |
| |
| Map<EntityHolder, EntityHolder> mapSrcDstEntities = new HashMap<>(); |
| Multimap<Entity, FileLink> mapFileLinksReplaced = ArrayListMultimap.create(); |
| Multimap<Entity, FileLink> mapFileLinksUploaded = ArrayListMultimap.create(); |
| |
| List<File> listFilesDownloadedToTempDir = new ArrayList<>(); |
| Map<String, FileLink> mapFileLinksExtComp = new HashMap<>(); |
| |
| public TransferBase(ApplicationContext src, ApplicationContext dst) { |
| contextSrc = src; |
| entityManagerSrc = contextSrc.getEntityManager() |
| .orElseThrow(() -> new ServiceNotProvidedException(EntityManager.class)); |
| |
| contextDst = dst; |
| entityManagerDst = contextDst.getEntityManager() |
| .orElseThrow(() -> new ServiceNotProvidedException(EntityManager.class)); |
| entityFactoryDst = contextDst.getEntityFactory() |
| .orElseThrow(() -> new ServiceNotProvidedException(EntityFactory.class)); |
| modelManagerDst = contextDst.getModelManager() |
| .orElseThrow(() -> new ServiceNotProvidedException(ModelManager.class)); |
| |
| if (contextDst.getFileService().isPresent()) { |
| fileServiceDst = contextDst.getFileService().get(); |
| } |
| |
| if (contextSrc.getFileService().isPresent()) { |
| fileServiceSrc = contextSrc.getFileService().get(); |
| } |
| |
| } |
| |
| ListMultimap<Class<? extends Entity>, Entity> loadParents(List<? extends Entity> entities) { |
| List<Entity> list = entities.stream().filter(e -> !isSupported(e)).collect(Collectors.toList()); |
| if (!list.isEmpty()) { |
| throw new ApiCopyException("Entity " + list + " not supported!"); |
| } |
| LinkedListMultimap<Class<? extends Entity>, Entity> byType = LinkedListMultimap.create(); |
| entities.forEach(e -> byType.put(e.getClass(), e)); |
| |
| byType.get(Measurement.class) |
| .forEach(e -> byType.put(TestStep.class, entityManagerSrc.loadParent(e, TestStep.class).get())); |
| byType.get(TestStep.class) |
| .forEach(e -> byType.put(Test.class, entityManagerSrc.loadParent(e, Test.class).get())); |
| byType.get(Test.class).forEach(e -> byType.put(Pool.class, entityManagerSrc.loadParent(e, Pool.class).get())); |
| byType.get(Pool.class) |
| .forEach(e -> byType.put(Project.class, entityManagerSrc.loadParent(e, Project.class).get())); |
| |
| entities.forEach(e -> byType.remove(e.getClass(), e)); |
| return byType; |
| } |
| |
| boolean isSupported(Entity e) { |
| return supportedRootEntities.contains(e.getClass()); |
| } |
| |
| <T extends Entity> Optional<T> fetchOne(SearchService searchService, Class<T> entityClass, Filter filter) { |
| List<T> results = searchService.fetch(entityClass, filter); |
| |
| if (results.isEmpty()) { |
| return Optional.empty(); |
| } else if (results.size() == 1) { |
| return Optional.of(results.get(0)); |
| } else { |
| throw new IllegalStateException(String.format("Expected at most one instance of %s, but found %s!", |
| entityClass.getName(), results.size())); |
| } |
| } |
| |
| <T extends Entity> Optional<T> fetchOne(EntityManager entityManager, Class<T> entityClass, String name) { |
| final List<T> results = entityManager.loadAll(entityClass, name); |
| |
| if (results.isEmpty()) { |
| return Optional.empty(); |
| } else if (results.size() == 1) { |
| return Optional.of(results.get(0)); |
| } else { |
| throw new IllegalStateException(String.format("Expected at most one instance of %s, but found %s!", |
| entityClass.getName(), results.size())); |
| } |
| } |
| |
| <T extends Entity> Optional<T> fetchChild(EntityManager entityManager, Entity parent, Class<T> childEntityClass, |
| String name) { |
| List<T> results = entityManagerDst.loadChildren(parent, childEntityClass, name); |
| if (results.isEmpty()) { |
| return Optional.empty(); |
| } else if (results.size() == 1) { |
| return Optional.of(results.get(0)); |
| } else { |
| throw new IllegalStateException(String.format("Expected at most one instance of %s, but found %s!", |
| childEntityClass.getName(), results.size())); |
| } |
| } |
| |
| boolean isNewEntity(Entity entity) { |
| return (Strings.isNullOrEmpty(entity.getID()) || Long.valueOf(entity.getID()) <= 0); |
| } |
| |
| void persist(Transaction transaction, Entity entity) { |
| if (isNewEntity(entity)) { |
| transaction.create(Lists.newArrayList(entity)); |
| } else { |
| transaction.update(Lists.newArrayList(entity)); |
| } |
| } |
| |
| void persist(Transaction transaction, List<? extends Entity> entities) { |
| List<Entity> newEntities = new ArrayList<>(); |
| List<Entity> updateEntities = new ArrayList<>(); |
| for (Entity entity : entities) { |
| if (isNewEntity(entity)) { |
| newEntities.add(entity); |
| } else { |
| updateEntities.add(entity); |
| } |
| } |
| transaction.create(newEntities); |
| transaction.update(updateEntities); |
| } |
| |
| Channel copyChannel(Channel channelSrc, Measurement measurementParentDst, List<Channel> existingChannels, |
| Map<String, Optional<Quantity>> quantitiesByName, Transaction transaction) { |
| EntityHolder ehSrc = new EntityHolder(channelSrc, entityManagerSrc); |
| |
| EntityHolder ehDst = mapSrcDstEntities.get(ehSrc); |
| |
| if (null == ehDst) { |
| LOG.trace("Copying Channel '{}'", channelSrc.getName()); |
| |
| Quantity quantity = quantitiesByName.getOrDefault(channelSrc.getQuantity().getName(), Optional.empty()) |
| .orElseThrow(() -> new ApiCopyException( |
| String.format("Cannot find Quantity with name '%s' in destination!", |
| channelSrc.getQuantity().getName()))); |
| |
| Channel channelDst = existingChannels.stream().filter(c -> c.getName().equals(channelSrc.getName())) |
| .findAny().orElseGet( |
| () -> entityFactoryDst.createChannel(channelSrc.getName(), measurementParentDst, quantity)); |
| |
| copyValues(channelSrc, channelDst, Arrays.asList("Id"), false); // initially ignored in export: |
| // "Name" |
| |
| persist(transaction, channelDst); |
| |
| ehDst = new EntityHolder(channelDst, entityManagerDst); |
| mapSrcDstEntities.put(ehSrc, ehDst); |
| } |
| |
| return (Channel) ehDst.getEntity(); |
| } |
| |
| void copyValues(Entity srcEntity, Entity dstEntity, List<String> ignoredAttributes) { |
| copyValues(srcEntity, dstEntity, ignoredAttributes, false); |
| } |
| |
| void copyValues(Entity srcEntity, Entity dstEntity, List<String> ignoredAttributes, boolean onlyValid) { |
| Set<String> valueNamesDst = dstEntity.getValues().keySet(); |
| for (Map.Entry<String, Value> me : srcEntity.getValues().entrySet()) { |
| String key = me.getKey(); |
| if (!ignoredAttributes.contains(key) && valueNamesDst.contains(key)) { |
| Value valueSrc = me.getValue(); |
| |
| if (onlyValid && !valueSrc.isValid()) { |
| continue; |
| } |
| Value value = dstEntity.getValue(me.getKey()); |
| |
| if (isFileLinkDataType(valueSrc.getValueType())) { |
| collectReplacedFileLinks(dstEntity, value, isReplaceFileLinks()); |
| |
| if (valueSrc.isValid()) { |
| uploadFiles(srcEntity, dstEntity, valueSrc); |
| } |
| |
| if (ValueType.FILE_LINK_SEQUENCE.equals(valueSrc.getValueType()) && !isReplaceFileLinks()) { |
| FileLink[] existingFileLinks = value.extract(ValueType.FILE_LINK_SEQUENCE); |
| FileLink[] newFileLinks = valueSrc.extract(ValueType.FILE_LINK_SEQUENCE); |
| valueSrc.set(ArrayUtils.addAll(existingFileLinks, newFileLinks)); |
| } |
| |
| } |
| |
| try { |
| value.set(valueSrc.extract()); |
| } catch (IllegalArgumentException e) { |
| throw new ApiCopyException( |
| "Cannot set value for " + dstEntity.getName() + "." + me.getKey() + ": " + e.getMessage(), |
| e); |
| } |
| value.setValid(valueSrc.isValid()); |
| } |
| } |
| |
| } |
| |
| private void collectReplacedFileLinks(Entity dstEntity, Value value, boolean replaceFileLinks) { |
| if (ValueType.FILE_LINK.equals(value.getValueType()) && value.isValid()) { |
| FileLink fileToDelete = value.extract(); |
| mapFileLinksReplaced.put(dstEntity, fileToDelete); |
| } else if (ValueType.FILE_LINK_SEQUENCE.equals(value.getValueType()) && replaceFileLinks) { |
| FileLink[] fileLinksToDelete = value.extract(); |
| mapFileLinksReplaced.putAll(dstEntity, Arrays.asList(fileLinksToDelete)); |
| } |
| } |
| |
| /** |
| * |
| * @param valueType |
| * @return |
| */ |
| private boolean isFileLinkDataType(ValueType<?> valueType) { |
| boolean isFileDataType = false; |
| |
| if (ValueType.FILE_LINK_SEQUENCE.equals(valueType) || ValueType.FILE_LINK.equals(valueType)) { |
| isFileDataType = true; |
| } |
| return isFileDataType; |
| } |
| |
| /** |
| * Uploading file of srcEntity and set the filelink to the dstEntity. Collect |
| * additionally the uploaded FileLinks in a map |
| * |
| * @param srcEntity |
| * @param dstEntity |
| * @param valueSrc |
| */ |
| private void uploadFiles(Entity srcEntity, Entity dstEntity, Value valueSrc) { |
| try { |
| if (fileServiceSrc != null && fileServiceDst != null) { |
| |
| if (ValueType.FILE_LINK_SEQUENCE.equals(valueSrc.getValueType())) { |
| |
| List<FileLink> fileLinkList = downloadSourceFiles(srcEntity, |
| Arrays.asList(valueSrc.extract(ValueType.FILE_LINK_SEQUENCE))); |
| fileServiceDst.uploadSequential(dstEntity, fileLinkList, null); |
| valueSrc.set(fileLinkList.toArray(new FileLink[fileLinkList.size()])); |
| mapFileLinksUploaded.putAll(dstEntity, fileLinkList); |
| } else if (ValueType.FILE_LINK.equals(valueSrc.getValueType())) { |
| FileLink fileLink = downloadSourceFile(srcEntity, valueSrc.extract(ValueType.FILE_LINK)); |
| fileServiceDst.uploadSequential(dstEntity, Collections.singletonList(fileLink), null); |
| valueSrc.set(fileLink); |
| mapFileLinksUploaded.put(dstEntity, fileLink); |
| } |
| } |
| |
| } catch (IOException e) { |
| throw new ApiCopyException(e.getLocalizedMessage(), e); |
| } |
| |
| } |
| |
| private List<FileLink> downloadSourceFiles(Entity srcEntity, List<FileLink> fileLinkList) throws IOException { |
| List<FileLink> returnList = new ArrayList<FileLink>(); |
| |
| for (FileLink fileLink : fileLinkList) { |
| returnList.add(downloadSourceFile(srcEntity, fileLink)); |
| } |
| |
| return returnList; |
| } |
| |
| private FileLink downloadSourceFile(Entity srcEntity, FileLink fileLinkSrc) throws IOException { |
| Path targetPath = Files.createTempDir().toPath(); |
| Path filePathAbsolute = targetPath.resolve(fileLinkSrc.getFileName()); |
| fileServiceSrc.download(srcEntity, targetPath, fileLinkSrc); |
| listFilesDownloadedToTempDir.add(filePathAbsolute.toFile()); |
| return FileLink.newLocal(filePathAbsolute); |
| } |
| |
| WriteRequest createWriteRequest(ChannelGroup channelGroupDst, Channel channelDst, MeasuredValues measuredValues, |
| Unit sourceUnit) { |
| WriteRequestBuilder wrb = WriteRequest.create(channelGroupDst, channelDst, measuredValues.getAxisType()); |
| NumericalValuesBuilder builder = null; |
| SequenceRepresentation seqRep = measuredValues.getSequenceRepresentation(); |
| ScalarType scalarType = measuredValues.getScalarType(); |
| boolean independent = measuredValues.isIndependent(); |
| double[] generationParameters = measuredValues.getGenerationParameters(); |
| |
| if (seqRep.isExternal() && measuredValues.hasExternalComponents()) { |
| try { |
| List<FileLink> listFileLinksNew = new ArrayList<>(); |
| for (ExternalComponent extComp : measuredValues.getExternalComponents()) { |
| FileLink fileLink = extComp.getFileLink(); |
| if (fileLink != null) { |
| FileLink fileLinkNew = mapFileLinksExtComp.get(fileLink.getRemotePath()); |
| if (fileLinkNew == null) { |
| fileLinkNew = downloadSourceFile(sourceUnit, fileLink); |
| mapFileLinksExtComp.put(fileLink.getRemotePath(), fileLinkNew); |
| listFileLinksNew.add(fileLinkNew); |
| } |
| extComp.setFileLink(fileLinkNew); |
| } |
| |
| FileLink flagsFileLink = extComp.getFlagsFileLink(); |
| if (flagsFileLink != null) { |
| FileLink flagsFileLinkNew = mapFileLinksExtComp.get(flagsFileLink.getRemotePath()); |
| if (flagsFileLinkNew == null) { |
| flagsFileLinkNew = downloadSourceFile(sourceUnit, flagsFileLink); |
| mapFileLinksExtComp.put(flagsFileLink.getRemotePath(), flagsFileLinkNew); |
| listFileLinksNew.add(flagsFileLinkNew); |
| } |
| extComp.setFlagsFileLink(flagsFileLinkNew); |
| } |
| } |
| |
| if (fileServiceSrc != null && fileServiceDst != null && !listFileLinksNew.isEmpty()) { |
| fileServiceDst.uploadSequential(channelDst, listFileLinksNew, null); |
| mapFileLinksUploaded.putAll(channelDst, listFileLinksNew); |
| } |
| } catch (IOException e) { |
| throw new ApiCopyException(e.getLocalizedMessage(), e); |
| } |
| } |
| |
| if (SequenceRepresentation.EXPLICIT.equals(seqRep)) { |
| builder = wrb.explicit(); |
| } else if (SequenceRepresentation.EXPLICIT_EXTERNAL.equals(seqRep)) { |
| return wrb.explicitExternal().externalComponents(scalarType, measuredValues.getExternalComponents()) |
| .independent(independent).build(); |
| } else if (SequenceRepresentation.IMPLICIT_CONSTANT.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 1); |
| |
| return wrb.implicitConstant(scalarType, generationParameters[0]).build(); |
| } else if (SequenceRepresentation.IMPLICIT_LINEAR.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 2); |
| |
| return wrb.implicitLinear(scalarType, generationParameters[0], generationParameters[1]) |
| .independent(independent).build(); |
| } else if (SequenceRepresentation.IMPLICIT_SAW.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 3); |
| |
| return wrb |
| .implicitSaw(scalarType, generationParameters[0], generationParameters[1], generationParameters[2]) |
| .build(); |
| } else if (SequenceRepresentation.RAW_LINEAR.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 2); |
| |
| builder = wrb.rawLinear(generationParameters[0], generationParameters[1]); |
| |
| } else if (SequenceRepresentation.RAW_LINEAR_EXTERNAL.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 2); |
| |
| return wrb.rawLinearExternal(generationParameters[0], generationParameters[1]) |
| .externalComponents(scalarType, measuredValues.getExternalComponents()).independent(independent) |
| .build(); |
| } else if (SequenceRepresentation.RAW_LINEAR_CALIBRATED.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 3); |
| |
| builder = wrb.rawLinearCalibrated(generationParameters[0], generationParameters[1], |
| generationParameters[2]); |
| } else if (SequenceRepresentation.RAW_LINEAR_CALIBRATED_EXTERNAL.equals(seqRep)) { |
| checkGenerationParameters(generationParameters, 3); |
| |
| return wrb |
| .rawLinearCalibratedExternal(generationParameters[0], generationParameters[1], |
| generationParameters[2]) |
| .externalComponents(scalarType, measuredValues.getExternalComponents()).independent(independent) |
| .build(); |
| } else if (SequenceRepresentation.RAW_POLYNOMIAL.equals(seqRep)) { |
| builder = wrb.rawPolynomial(generationParameters); |
| } else if (SequenceRepresentation.RAW_POLYNOMIAL_EXTERNAL.equals(seqRep)) { |
| return wrb.rawPolynomialExternal(generationParameters) |
| .externalComponents(scalarType, measuredValues.getExternalComponents()).independent(independent) |
| .build(); |
| } |
| |
| if (scalarType.isString()) { |
| String[] values = new String[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<String> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, AnyTypeValuesBuilder.class).stringValues(values, flags).build(); |
| } else if (scalarType.isDate()) { |
| LocalDateTime[] values = new LocalDateTime[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<LocalDateTime> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, AnyTypeValuesBuilder.class).dateValues(values, flags).independent(independent) |
| .build(); |
| } else if (scalarType.isBoolean()) { |
| boolean[] values = new boolean[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Boolean> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, AnyTypeValuesBuilder.class).booleanValues(values, flags).build(); |
| } else if (scalarType.isByte()) { |
| byte[] values = new byte[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Byte> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return builder.byteValues(values, flags).independent(independent).build(); |
| } else if (scalarType.isShort()) { |
| short[] values = new short[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Short> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return builder.shortValues(values, flags).sourceUnit(sourceUnit).independent(independent).build(); |
| } else if (scalarType.isInteger()) { |
| int[] values = new int[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Integer> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return builder.integerValues(values, flags).sourceUnit(sourceUnit).independent(independent).build(); |
| } else if (scalarType.isLong()) { |
| long[] values = new long[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Long> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return builder.longValues(values, flags).sourceUnit(sourceUnit).independent(independent).build(); |
| } else if (scalarType.isFloat()) { |
| float[] values = new float[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Float> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return builder.floatValues(values, flags).sourceUnit(sourceUnit).independent(independent).build(); |
| } else if (scalarType.isDouble()) { |
| double[] values = new double[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<Double> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return builder.doubleValues(values, flags).sourceUnit(sourceUnit).independent(independent).build(); |
| } else if (scalarType.isByteStream()) { |
| byte[][] values = new byte[measuredValues.getLength()][]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<byte[]> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, AnyTypeValuesBuilder.class).byteStreamValues(values, flags).build(); |
| } else if (scalarType.isFloatComplex()) { |
| FloatComplex[] values = new FloatComplex[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<FloatComplex> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, ComplexNumericalValuesBuilder.class).floatComplexValues(values, flags) |
| .sourceUnit(sourceUnit).build(); |
| } else if (scalarType.isDoubleComplex()) { |
| DoubleComplex[] values = new DoubleComplex[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<DoubleComplex> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, ComplexNumericalValuesBuilder.class).doubleComplexValues(values, flags) |
| .sourceUnit(sourceUnit).build(); |
| } else if (scalarType.isFileLink()) { |
| FileLink[] values = new FileLink[measuredValues.getLength()]; |
| boolean[] flags = new boolean[values.length]; |
| ValueIterator<FileLink> iter = measuredValues.iterator(); |
| int count = 0; |
| while (iter.hasNext()) { |
| flags[count] = iter.isValid(); |
| values[count++] = iter.next(); |
| } |
| |
| return castBuilder(builder, AnyTypeValuesBuilder.class).fileLinkValues(values, flags).build(); |
| } else if (scalarType.isBlob()) { |
| Object value = null; |
| ValueIterator<Object> iter = measuredValues.iterator(); |
| while (iter.hasNext()) { |
| value = iter.next(); |
| } |
| |
| return castBuilder(builder, AnyTypeValuesBuilder.class).blobValue(value).build(); |
| } else { |
| throw new IllegalStateException( |
| String.format("Unsupported ScalarType %s in MeasuredValues!", scalarType.name())); |
| } |
| } |
| |
| void checkGenerationParameters(double[] generationParameters, int expectedLength) { |
| if (null == generationParameters || generationParameters.length < expectedLength) { |
| throw new IllegalStateException(String.format("Number of generation parameters is %d, expected %d!", |
| (null == generationParameters ? 0 : generationParameters.length), expectedLength)); |
| } |
| } |
| |
| <T extends NumericalValuesBuilder> T castBuilder(NumericalValuesBuilder builder, Class<T> cls) { |
| if (!builder.getClass().isAssignableFrom(cls)) { |
| throw new IllegalStateException(String.format( |
| "Error creating the write values builder, expected class is %s, actual class is %s (likely column data type and sequence representation mismatch)!", |
| cls.getName(), (null == builder ? "???" : builder.getClass().getName()))); |
| } |
| |
| return cls.cast(builder); |
| } |
| |
| /** |
| * Delete all replaced file links |
| */ |
| void deleteFilesOfReplacedFileLinks() { |
| mapFileLinksReplaced.asMap().forEach((entity, fileLinkList) -> { |
| fileServiceDst.delete(entity, fileLinkList); |
| }); |
| } |
| |
| void clearReplacedFileLinkCache() { |
| mapFileLinksReplaced.clear(); |
| } |
| |
| /** |
| * Delete all uploaded files, is necessary if the Import will be canceled |
| */ |
| void deleteFilesOfUploadedFileLinks() { |
| mapFileLinksUploaded.asMap().forEach((entity, fileLinkList) -> { |
| fileServiceDst.delete(entity, fileLinkList); |
| }); |
| } |
| |
| void deleteLocalTempFiles() { |
| listFilesDownloadedToTempDir.forEach(file -> deleteFileAndEmptyParentFolder(file)); |
| } |
| |
| void clearUploadedFileLinkCache() { |
| mapFileLinksUploaded.clear(); |
| } |
| |
| void deleteFileAndEmptyParentFolder(File file) { |
| file.delete(); |
| Path dir = Paths.get(file.getAbsolutePath()).getParent(); |
| if (dir != null && dir.toFile().list().length == 0) { |
| dir.toFile().delete(); |
| } |
| } |
| |
| public boolean isReplaceFileLinks() { |
| return false; |
| } |
| |
| } |
