AbstractMessageWriter.java

  1. /* Copyright 2002-2022 CS GROUP
  2.  * Licensed to CS GROUP (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.files.ccsds.utils.generation;

  19. import java.io.IOException;
  20. import java.time.ZoneOffset;
  21. import java.time.ZonedDateTime;

  23. import org.orekit.files.ccsds.definitions.TimeConverter;
  24. import org.orekit.files.ccsds.ndm.NdmConstituent;
  25. import org.orekit.files.ccsds.section.Header;
  26. import org.orekit.files.ccsds.section.HeaderKey;
  27. import org.orekit.files.ccsds.section.Segment;
  28. import org.orekit.files.ccsds.section.XmlStructureKey;
  29. import org.orekit.files.ccsds.utils.ContextBinding;
  30. import org.orekit.files.ccsds.utils.FileFormat;
  31. import org.orekit.time.AbsoluteDate;
  32. import org.orekit.time.DateComponents;
  33. import org.orekit.time.DateTimeComponents;
  34. import org.orekit.time.TimeComponents;
  35. import org.orekit.time.TimeScale;

  37. /**
  38.  * Base class for Navigation Data Message (NDM) files.
  39.  * @param <H> type of the header
  40.  * @param <S> type of the segments
  41.  * @author Luc Maisonobe
  42.  * @since 11.0
  43.  */
  44. public abstract class AbstractMessageWriter<H extends Header, S extends Segment<?, ?>, F extends NdmConstituent<H, S>>
  45.     implements MessageWriter<H, S, F> {

  47.     /** Default value for {@link HeaderKey#ORIGINATOR}. */
  48.     public static final String DEFAULT_ORIGINATOR = "OREKIT";

  50.     /** Root element for XML files. */
  51.     private final String root;

  53.     /** Key for format version. */
  54.     private final String formatVersionKey;

  56.     /** Default format version. */
  57.     private final double defaultVersion;

  59.     /** Current context binding. */
  60.     private ContextBinding context;

  62.     /** Current converter for dates. */
  63.     private TimeConverter timeConverter;

  65.     /** Current format version. */
  66.     private double version;

  68.     /**
  69.      * Constructor used to create a new NDM writer configured with the necessary parameters
  70.      * to successfully fill in all required fields that aren't part of a standard object.
  71.      * <p>
  72.      * If creation date and originator are not present in header, built-in defaults will be used
  73.      * </p>
  74.      * @param root root element for XML files
  75.      * @param formatVersionKey key for format version
  76.      * @param defaultVersion default format version
  77.      * @param context context binding (may be reset for each segment)
  78.      */
  79.     public AbstractMessageWriter(final String root, final String formatVersionKey,
  80.                                  final double defaultVersion, final ContextBinding context) {

  82.         this.root             = root;
  83.         this.defaultVersion   = defaultVersion;
  84.         this.formatVersionKey = formatVersionKey;
  85.         this.version          = defaultVersion;

  87.         setContext(context);

  89.     }

  91.     /** Reset context binding.
  92.      * @param context context binding to use
  93.      */
  94.     public void setContext(final ContextBinding context) {
  95.         this.context       = context;
  96.         this.timeConverter = context.getTimeSystem().getConverter(context);
  97.     }

  99.     /** Get the current context.
  100.      * @return current context
  101.      */
  102.     public ContextBinding getContext() {
  103.         return context;
  104.     }

  106.     /** Get the current time converter.
  107.      * @return current time converter
  108.      */
  109.     public TimeConverter getTimeConverter() {
  110.         return timeConverter;
  111.     }

  113.     /** Get the default format version.
  114.      * @return default format version
  115.      */
  116.     public double getDefaultVersion() {
  117.         return defaultVersion;
  118.     }

  120.     /** {@inheritDoc} */
  121.     @Override
  122.     public void writeHeader(final Generator generator, final H header) throws IOException {

  124.         final ZonedDateTime zdt = ZonedDateTime.now(ZoneOffset.UTC);
  125.         final TimeScale     utc = context.getDataContext().getTimeScales().getUTC();
  126.         final AbsoluteDate date = new AbsoluteDate(zdt.getYear(), zdt.getMonthValue(), zdt.getDayOfMonth(),
  127.                                                    zdt.getHour(), zdt.getMinute(), zdt.getSecond(),
  128.                                                    utc);

  130.         // validate before writing
  131.         if (header != null) {

  133.             if (!Double.isNaN(header.getFormatVersion())) {
  134.                 // save format version for validating segments
  135.                 version = header.getFormatVersion();
  136.             }

  138.             if (header.getCreationDate() == null) {
  139.                 header.setCreationDate(date);
  140.             }

  142.             if (header.getOriginator() == null) {
  143.                 header.setOriginator(DEFAULT_ORIGINATOR);
  144.             }

  146.             header.validate(version);

  148.         }

  150.         generator.startMessage(root, formatVersionKey, version);

  152.         if (generator.getFormat() == FileFormat.XML) {
  153.             generator.enterSection(XmlStructureKey.header.name());
  154.         }

  156.         // comments are optional
  157.         if (header != null) {
  158.             generator.writeComments(header.getComments());
  159.         }

  161.         // creation date is informational only, but mandatory and always in UTC
  162.         final DateTimeComponents creationDate = ((header == null) ? date : header.getCreationDate()).getComponents(utc);
  163.         final DateComponents     dc           = creationDate.getDate();
  164.         final TimeComponents     tc           = creationDate.getTime();
  165.         generator.writeEntry(HeaderKey.CREATION_DATE.name(),
  166.                              generator.dateToString(dc.getYear(), dc.getMonth(), dc.getDay(),
  167.                                                     tc.getHour(), tc.getMinute(), tc.getSecond()),
  168.                              null, true);

  170.         // Use built-in default if mandatory originator not present
  171.         generator.writeEntry(HeaderKey.ORIGINATOR.name(),
  172.                              header == null ? DEFAULT_ORIGINATOR : header.getOriginator(),
  173.                              null, true);

  175.         if (header != null) {
  176.             generator.writeEntry(HeaderKey.MESSAGE_ID.name(), header.getMessageId(), null, false);
  177.         }

  179.         if (generator.getFormat() == FileFormat.XML) {
  180.             generator.exitSection();
  181.         }

  183.         // add an empty line for presentation
  184.         generator.newLine();

  186.         if (generator.getFormat() == FileFormat.XML) {
  187.             generator.enterSection(XmlStructureKey.body.name());
  188.         }

  190.     }

  192.     /** {@inheritDoc} */
  193.     @Override
  194.     public void writeSegment(final Generator generator, final S segment) throws IOException {

  196.         // validate before writing
  197.         segment.getMetadata().validate(version);
  198.         segment.getData().validate(version);

  200.         if (generator.getFormat() == FileFormat.XML) {
  201.             generator.enterSection(XmlStructureKey.segment.name());
  202.         }
  203.         writeSegmentContent(generator, version, segment);
  204.         if (generator.getFormat() == FileFormat.XML) {
  205.             generator.exitSection();
  206.         }

  208.     }

  210.     /** Write one segment content (without XML wrapping).
  211.      * @param generator generator to use for producing output
  212.      * @param formatVersion format version to use
  213.      * @param segment segment to write
  214.      * @throws IOException if any buffer writing operations fails
  215.      */
  216.     public abstract void writeSegmentContent(Generator generator, double formatVersion, S segment) throws IOException;

  218.     /** {@inheritDoc} */
  219.     @Override
  220.     public void writeFooter(final Generator generator) throws IOException {
  221.         if (generator.getFormat() == FileFormat.XML) {
  222.             generator.exitSection();
  223.         }
  224.         generator.endMessage(root);
  225.     }

  227. }
Created with JaCoCo 0.8.7.202105040129