Healing for enforcing HEAT validation

Healing implementation for enforcing HEAT validation after upload.

Change-Id: I56614245d52a26d570cf2a4548057b9025e1f5cc
Issue-ID: SDC-1057
Signed-off-by: shrikantawachar <shrikant.awachar@amdocs.com>

3 files changed, 403 insertions, 32 deletions

diff --git a/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/java/org/openecomp/sdc/healing/impl/HealingManagerImpl.java b/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/java/org/openecomp/sdc/healing/impl/HealingManagerImpl.java
index eef8c3cd44..c13e89cb76 100644
--- a/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/java/org/openecomp/sdc/healing/impl/HealingManagerImpl.java
+++ b/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/java/org/openecomp/sdc/healing/impl/HealingManagerImpl.java
@@ -65,39 +65,39 @@ public class HealingManagerImpl implements HealingManager {
   public Optional<Version> healItemVersion(final String itemId, final Version version,
                                            final ItemType itemType, final boolean force) {
     String user = getUser();
-    if (force || isPrivateHealingNeededByFlag(itemId, version.getId(), user)) {
-
-      Map<String, Collection<String>> healersByType = getItemHealers(itemType);
-      List<String> failureMessages = new LinkedList<>();
-      List<Healer> structureHealersToRun =
-          getHealersToRun(healersByType.get(HealerType.structure.name()), itemId, version,
-              failureMessages);
-      List<Healer> dataHealersToRun =
-          getHealersToRun(healersByType.get(HealerType.data.name()), itemId, version,
-              failureMessages);
-
-      if (structureHealersToRun.isEmpty() && dataHealersToRun.isEmpty()) {
-        markAsHealed(itemId, version.getId(), user);
-        markAsHealed(itemId, version.getId(), PUBLIC_USER);
-        return Optional.empty();
-      }
-
-      Optional<Version> healVersion = getHealVersion(itemId, version);
-      if (!healVersion.isPresent()) {
-        // do NOT turn off flag here (in thought of saving version calculate performance next
-        // time) because maybe next time the next version will be available (due to deletion of
-        // the taken one)
-        return Optional.empty();
-      }
+    if (!force && !isPrivateHealingNeededByFlags(itemId, version.getId(), user)) {
+      return Optional.empty();
+    }
 
-      failureMessages.addAll(
-          doHeal(itemId, healVersion.get(), version, structureHealersToRun, dataHealersToRun, user,
-              force));
+    Map<String, Collection<String>> healersByType = getItemHealers(itemType);
+    List<String> failureMessages = new LinkedList<>();
+    List<Healer> structureHealersToRun =
+        getHealersToRun(healersByType.get(HealerType.structure.name()), itemId, version,
+            failureMessages);
+    List<Healer> dataHealersToRun =
+        getHealersToRun(healersByType.get(HealerType.data.name()), itemId, version,
+            failureMessages);
+
+    if (structureHealersToRun.isEmpty() && dataHealersToRun.isEmpty()) {
+      markAsHealed(itemId, version.getId(), user);
+      markAsHealed(itemId, version.getId(), PUBLIC_USER);
+      return Optional.empty();
+    }
 
-      handleFailures(failureMessages);
-      return healVersion;
+    Optional<Version> healVersion = getHealVersion(itemId, version);
+    if (!healVersion.isPresent()) {
+      // do NOT turn off flag here (in thought of saving version calculate performance next
+      // time) because maybe next time the next version will be available (due to deletion of
+      // the taken one)
+      return Optional.empty();
     }
-    return Optional.empty();
+
+    failureMessages.addAll(
+        doHeal(itemId, healVersion.get(), version, structureHealersToRun, dataHealersToRun, user,
+            force));
+    handleFailures(failureMessages);
+
+    return healVersion;
   }
 
   private Optional<Version> getHealVersion(String itemId, Version version) {
@@ -200,7 +200,7 @@ public class HealingManagerImpl implements HealingManager {
     return failureMessages;
   }
 
-  private boolean isPrivateHealingNeededByFlag(String itemId, String version, String user) {
+  private boolean isPrivateHealingNeededByFlags(String itemId, String version, String user) {
     Optional<Boolean> userHealingFlag = getHealingFlag(itemId, version, user);
     return userHealingFlag.orElseGet(() -> isPublicHealingNeededByFlag(itemId, version));
   }
diff --git a/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/resources/entityHealingConfiguration.json b/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/resources/entityHealingConfiguration.json
index 2fc23372de..51de9d0802 100644
--- a/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/resources/entityHealingConfiguration.json
+++ b/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-core/src/main/resources/entityHealingConfiguration.json
@@ -1,7 +1,8 @@
 {
   "vsp": {
     "structure": [
-      "org.openecomp.sdc.healing.healers.OwnerHealer"
+      "org.openecomp.sdc.healing.healers.OwnerHealer",
+      "org.openecomp.sdc.healing.healers.NetworkPackageHealer"
     ],
     "data": [
       "org.openecomp.sdc.healing.healers.ToscaServiceModelHealer"
diff --git a/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-impl/src/main/java/org/openecomp/sdc/healing/healers/NetworkPackageHealer.java b/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-impl/src/main/java/org/openecomp/sdc/healing/healers/NetworkPackageHealer.java
new file mode 100644
index 0000000000..756521d49d
--- /dev/null
+++ b/openecomp-be/lib/openecomp-healing-lib/openecomp-sdc-healing-impl/src/main/java/org/openecomp/sdc/healing/healers/NetworkPackageHealer.java
@@ -0,0 +1,370 @@
+/*
+ * Copyright © 2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openecomp.sdc.healing.healers;
+
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
+import com.amdocs.zusammen.datatypes.Id;
+import com.amdocs.zusammen.datatypes.SessionContext;
+import com.amdocs.zusammen.datatypes.item.Action;
+import com.amdocs.zusammen.datatypes.item.ElementContext;
+import com.amdocs.zusammen.utils.fileutils.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang.ArrayUtils;
+import org.apache.commons.lang.StringUtils;
+import org.openecomp.core.utilities.file.FileContentHandler;
+import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCode;
+import org.openecomp.sdc.common.utils.CommonUtil;
+import org.openecomp.sdc.datatypes.error.ErrorLevel;
+import org.openecomp.sdc.datatypes.model.ElementType;
+import org.openecomp.sdc.healing.interfaces.Healer;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDao;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.VendorSoftwareProductInfoDaoFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OnboardingMethod;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateCandidateData;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.OrchestrationTemplateEntity;
+import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails;
+import org.openecomp.sdc.vendorsoftwareproduct.factory.CandidateServiceFactory;
+import org.openecomp.sdc.vendorsoftwareproduct.services.filedatastructuremodule.CandidateService;
+import org.openecomp.sdc.vendorsoftwareproduct.services.utils.CandidateEntityBuilder;
+import org.openecomp.sdc.versioning.dao.types.Version;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.Collection;
+import java.util.Objects;
+
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildElement;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement;
+import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext;
+
+public class NetworkPackageHealer implements Healer {
+
+  private static final byte[] EMPTY_DATA_BYTES = "{}".getBytes();
+  private static final String MISSING_ORCHESTRATION_TEMPLATE_CANDIDATE_ERROR =
+      "Vsp with invalid structure: does not contain element OrchestrationTemplateCandidate";
+  private static final String MISSING_ORCHESTRATION_TEMPLATE_CANDIDATE_CONTENT_ERROR =
+      "Vsp with invalid structure: does not contain element OrchestrationTemplateCandidateContent"
+          + " under OrchestrationTemplateCandidate";
+
+  private static final String MISSING_VSP_MODEL_ERROR =
+      "Vsp with invalid structure: does not contain element VspModel";
+  private static final String MISSING_ORCHESTRATION_TEMPLATE_ERROR =
+      "Vsp with invalid structure: does not contain element OrchestrationTemplate"
+          + " under VspModel element";
+  private static final String MISSING_ORCHESTRATION_TEMPLATE_VALIDATE_DATA_ERROR =
+      "Vsp with invalid structure: does not contain element OrchestrationTemplateValidationData"
+          + " under OrchestrationTemplate element";
+
+  private VendorSoftwareProductInfoDao vspInfoDao;
+  private ZusammenAdaptor zusammenAdaptor;
+  private CandidateService candidateService;
+
+  public NetworkPackageHealer() {
+    this.vspInfoDao = VendorSoftwareProductInfoDaoFactory.getInstance().createInterface();
+    this.zusammenAdaptor = ZusammenAdaptorFactory.getInstance().createInterface();
+    this.candidateService = CandidateServiceFactory.getInstance().createInterface();
+  }
+
+  @Override
+  public boolean isHealingNeeded(String itemId, Version version) {
+    return OnboardingMethod.NetworkPackage.name()
+        .equals(vspInfoDao.get(new VspDetails(itemId, version)).getOnboardingMethod()) &&
+        isVspMissingAddedElements(itemId, version);
+  }
+
+  @Override
+  public void heal(String itemId, Version version) throws Exception {
+    SessionContext context = createSessionContext();
+    ElementContext elementContext = new ElementContext(itemId, version.getId());
+
+    Element candidateElement =
+        getElement(context, elementContext, null, ElementType.OrchestrationTemplateCandidate,
+            MISSING_ORCHESTRATION_TEMPLATE_CANDIDATE_ERROR);
+
+    Collection<Element> candidateSubs =
+        zusammenAdaptor.listElementData(context, elementContext, candidateElement.getElementId());
+
+    Id candidateValidationElementId =
+        creatIfAbsentCandidateValidationElementId(candidateSubs, context,
+        elementContext, candidateElement);
+
+    Element orchestrationTemplateElement = getOrchestrationTemplateElement(context, elementContext);
+
+    Collection<Element> orchestrationTemplateSubs = zusammenAdaptor
+        .listElementData(context, elementContext, orchestrationTemplateElement.getElementId());
+
+    Id structureElementId = createIfAbsentStructureElementId(orchestrationTemplateSubs, context,
+        elementContext, orchestrationTemplateElement);
+
+    Element orchestrationTemplateValidationElement = getOrchestrationTemplateValidationElement
+        (orchestrationTemplateSubs);
+
+    OrchestrationTemplateEntity orchestrationTemplateEntity =
+        getOrchestrationTemplateEntity(orchestrationTemplateElement,
+            orchestrationTemplateValidationElement);
+
+    if (StringUtils.isEmpty(orchestrationTemplateEntity.getFileSuffix())) {
+      return;
+    }
+
+    Element candidateContentElement = getCandidateContentElement(candidateSubs);
+
+    VspDetails vspDetails = vspInfoDao.get(new VspDetails(itemId, version));
+    if (isEqual(orchestrationTemplateEntity,
+        getCandidateData(candidateElement, candidateContentElement))) {
+
+      if (isProcessedEntityValid(orchestrationTemplateEntity)) {
+        emptyStructureElementAndSub(context, elementContext, candidateElement.getElementId(),
+            ElementType.OrchestrationTemplateCandidate, candidateContentElement.getElementId(),
+            ElementType.OrchestrationTemplateCandidateContent);
+
+        populateOrchestrationTemplateStructure(orchestrationTemplateElement.getData(),
+            structureElementId, vspDetails, context, elementContext);
+      } else {
+        emptyStructureElementAndSub(context, elementContext,
+            orchestrationTemplateElement.getElementId(), ElementType.OrchestrationTemplate,
+            orchestrationTemplateValidationElement.getElementId(),
+            ElementType.OrchestrationTemplateValidationData);
+
+        populateCandidateValidationData(context, elementContext, candidateValidationElementId,
+            orchestrationTemplateEntity.getValidationData());
+      }
+    } else {
+      populateOrchestrationTemplateStructure(orchestrationTemplateElement.getData(),
+          structureElementId, vspDetails, context, elementContext);
+    }
+  }
+
+  private boolean isVspMissingAddedElements(String vspId, Version version) {
+    SessionContext context = createSessionContext();
+    ElementContext elementContext = new ElementContext(vspId, version.getId());
+
+    return zusammenAdaptor.listElementsByName(context, elementContext, null,
+        ElementType.OrchestrationTemplateCandidate.name()).stream()
+        .noneMatch(candidateSub -> ElementType.OrchestrationTemplateCandidateValidationData.name()
+            .equals(candidateSub.getInfo().getName()));
+  }
+
+  private boolean isEqual(OrchestrationTemplateEntity orchestrationTemplateEntity,
+                          OrchestrationTemplateCandidateData orchestrationTemplateCandidateData) {
+    return orchestrationTemplateEntity.getFileName()
+        .equals(orchestrationTemplateCandidateData.getFileName()) &&
+        orchestrationTemplateEntity.getFileSuffix()
+            .equals(orchestrationTemplateCandidateData.getFileSuffix());
+  }
+
+  private boolean isProcessedEntityValid(OrchestrationTemplateEntity orchestrationTemplateEntity) {
+    return !orchestrationTemplateEntity.getValidationData().contains(ErrorLevel.ERROR.name());
+  }
+
+  private void populateCandidateValidationData(SessionContext context,
+                                               ElementContext elementContext,
+                                               Id candidateValidationElementId,
+                                               String validationData) {
+    ZusammenElement candidateValidationElement =
+        buildStructuralElement(ElementType.OrchestrationTemplateCandidateValidationData,
+            Action.UPDATE);
+    candidateValidationElement.setElementId(candidateValidationElementId);
+    candidateValidationElement.setData(new ByteArrayInputStream(validationData.getBytes()));
+
+    zusammenAdaptor.saveElement(context, elementContext, candidateValidationElement,
+        "Healed Orchestration Template Candidate Validation data");
+  }
+
+  private void populateOrchestrationTemplateStructure(InputStream processedFile,
+                                                      Id structureElementId, VspDetails vspDetails,
+                                                      SessionContext context,
+                                                      ElementContext elementContext)
+      throws Exception {
+    byte[] byteData = FileUtils.toByteArray(processedFile);
+    FileContentHandler contentMap =
+        CommonUtil.validateAndUploadFileContent(OnboardingTypesEnum.ZIP, byteData);
+    OrchestrationTemplateCandidateData orchestrationTemplateEntityData =
+        new CandidateEntityBuilder(candidateService)
+            .buildCandidateEntityFromZip(vspDetails, byteData, contentMap, null);
+    String fileDataStructure = orchestrationTemplateEntityData.getFilesDataStructure();
+
+    ZusammenElement orchestrationTemplateStructure =
+        buildStructuralElement(ElementType.OrchestrationTemplateStructure, Action.UPDATE);
+    orchestrationTemplateStructure.setElementId(structureElementId);
+    orchestrationTemplateStructure.setData(new ByteArrayInputStream(fileDataStructure.getBytes()));
+
+    zusammenAdaptor.saveElement(context, elementContext, orchestrationTemplateStructure,
+        "Healed Orchestration Template Structure");
+  }
+
+  private Element getOrchestrationTemplateElement(SessionContext context,
+                                                  ElementContext elementContext) {
+    ElementInfo vspModelElement = zusammenAdaptor
+        .getElementInfoByName(context, elementContext, null, ElementType.VspModel.name())
+        .orElseThrow(() -> new CoreException(new ErrorCode.ErrorCodeBuilder()
+            .withMessage(MISSING_VSP_MODEL_ERROR).build()));
+
+    return getElement(context, elementContext, vspModelElement.getId(),
+        ElementType.OrchestrationTemplate, MISSING_ORCHESTRATION_TEMPLATE_ERROR);
+  }
+
+  private Element getOrchestrationTemplateValidationElement(
+      Collection<Element> orchestrationTemplateSubs) {
+    return orchestrationTemplateSubs.stream()
+        .filter(orchestrationTemplateSub -> ElementType.OrchestrationTemplateValidationData.name()
+            .equals(orchestrationTemplateSub.getInfo().getName()))
+        .findFirst()
+        .orElseThrow(() -> new CoreException(new ErrorCode.ErrorCodeBuilder()
+            .withMessage(MISSING_ORCHESTRATION_TEMPLATE_VALIDATE_DATA_ERROR).build()));
+
+  }
+
+  private Element getCandidateContentElement(Collection<Element> candidateSubs) {
+    return candidateSubs.stream()
+        .filter(candidateSub -> ElementType.OrchestrationTemplateCandidateContent.name()
+            .equals(candidateSub.getInfo().getName()))
+        .findFirst()
+        .orElseThrow(() -> new CoreException(new ErrorCode.ErrorCodeBuilder()
+            .withMessage(MISSING_ORCHESTRATION_TEMPLATE_CANDIDATE_CONTENT_ERROR).build()));
+  }
+
+  private Id createIfAbsentStructureElementId(Collection<Element> orchestrationTemplateSubs,
+                                              SessionContext context, ElementContext elementContext,
+                                              Element orchestrationTemplateElement) {
+    return orchestrationTemplateSubs.stream()
+        .filter(orchestrationTemplateSub -> ElementType.OrchestrationTemplateStructure.name()
+            .equals(orchestrationTemplateSub.getInfo().getName()))
+        .findFirst().map(Element::getElementId)
+        .orElse(addStructureSubElement(context, elementContext,
+            ElementType.OrchestrationTemplateStructure,
+            orchestrationTemplateElement.getElementId()));
+  }
+
+  private Id creatIfAbsentCandidateValidationElementId(Collection<Element> candidateSubs,
+                                                       SessionContext context, ElementContext
+                                                 elementContext, Element candidateElement) {
+    return candidateSubs.stream()
+        .filter(candidateSub -> ElementType.OrchestrationTemplateCandidateValidationData.name()
+            .equals(candidateSub.getInfo().getName()))
+        .findFirst().map(Element::getElementId)
+        .orElse(addStructureSubElement(context, elementContext,
+            ElementType.OrchestrationTemplateCandidateValidationData,
+            candidateElement.getElementId()));
+  }
+
+  private Element getElement(SessionContext context, ElementContext elementContext,
+                             Id parentElementId, ElementType elementType, String errorMessage) {
+    return zusammenAdaptor
+        .getElementByName(context, elementContext, parentElementId, elementType.name())
+        .orElseThrow(() -> new CoreException(
+            new ErrorCode.ErrorCodeBuilder().withMessage(errorMessage).build()));
+  }
+
+  private OrchestrationTemplateEntity getOrchestrationTemplateEntity(
+      Element orchestrationTemplateElement, Element validationDataElement) {
+    OrchestrationTemplateEntity orchestrationTemplateEntity = new OrchestrationTemplateEntity();
+
+    if (isNotEmpty(orchestrationTemplateElement.getData())) {
+      orchestrationTemplateEntity.setContentData(
+          ByteBuffer.wrap(FileUtils.toByteArray(orchestrationTemplateElement.getData())));
+    }
+    orchestrationTemplateEntity.setFileSuffix(
+        validationDataElement.getInfo().getProperty(InfoPropertyName.FILE_SUFFIX.getVal()));
+    orchestrationTemplateEntity.setFileName(
+        validationDataElement.getInfo().getProperty(InfoPropertyName.FILE_NAME.getVal()));
+    if (isNotEmpty(validationDataElement.getData())) {
+      orchestrationTemplateEntity
+          .setValidationData(new String(FileUtils.toByteArray(validationDataElement.getData())));
+    }
+    return orchestrationTemplateEntity;
+  }
+
+  private OrchestrationTemplateCandidateData getCandidateData(Element candidateElement,
+                                                              Element candidateContentElement) {
+    OrchestrationTemplateCandidateData candidateData = new OrchestrationTemplateCandidateData();
+    candidateData
+        .setFilesDataStructure(new String(FileUtils.toByteArray(candidateElement.getData())));
+    candidateData
+        .setContentData(ByteBuffer.wrap(FileUtils.toByteArray(candidateContentElement.getData())));
+    candidateData.setFileSuffix(
+        candidateContentElement.getInfo().getProperty(InfoPropertyName.FILE_SUFFIX.getVal()));
+    candidateData.setFileName(
+        candidateContentElement.getInfo().getProperty(InfoPropertyName.FILE_NAME.getVal()));
+    return candidateData;
+  }
+
+  private Id addStructureSubElement(SessionContext context, ElementContext elementContext,
+                                    ElementType elementType, Id parentElementId) {
+    ZusammenElement newElement = buildStructuralElement(elementType, Action.CREATE);
+
+    ZusammenElement parentElement = buildElement(parentElementId, Action.IGNORE);
+    parentElement.addSubElement(newElement);
+
+    return zusammenAdaptor.saveElement(context, elementContext, parentElement,
+        String.format("Add element %s under element id %s", elementType.name(), parentElementId))
+        .getSubElements().iterator().next().getElementId();
+  }
+
+  private void emptyStructureElementAndSub(SessionContext context, ElementContext elementContext,
+                                           Id elementId, ElementType elementType, Id subElementId,
+                                           ElementType subElementType) {
+    ZusammenElement subElement = buildStructuralElement(subElementType, Action.UPDATE);
+    subElement.setElementId(subElementId);
+    subElement.setData(new ByteArrayInputStream(EMPTY_DATA_BYTES));
+
+    ZusammenElement element = buildStructuralElement(elementType, Action.UPDATE);
+    element.setElementId(elementId);
+    element.setData(new ByteArrayInputStream(EMPTY_DATA_BYTES));
+    element.addSubElement(subElement);
+
+    zusammenAdaptor.saveElement(context, elementContext, element,
+        String.format("Empty element %s and its sub element %s", elementType.name(),
+            subElementType.name()));
+  }
+
+  public enum InfoPropertyName {
+    FILE_SUFFIX("fileSuffix"),
+    FILE_NAME("fileName");
+
+    private String val;
+
+    InfoPropertyName(String val) {
+      this.val = val;
+    }
+
+    private String getVal() {
+      return val;
+    }
+  }
+
+  private boolean isNotEmpty(InputStream elementData) {
+    byte[] byteElementData;
+    if (Objects.isNull(elementData)) {
+      return false;
+    }
+    try {
+      byteElementData = IOUtils.toByteArray(elementData);
+    } catch (IOException e) {
+      return true;
+    }
+    return !ArrayUtils.isEmpty(byteElementData);
+  }
+}