Page History

import nl.wldelft.util.Arguments;

import nl.wldelft.util.BinaryUtils;

import nl.wldelft.util.Clasz;

import nl.wldelft.util.FastDateFormat;

import nl.wldelft.util.FileUtils;

import nl.wldelft.util.MathUtils;

import nl.wldelft.util.NumberType;

import nl.wldelft.util.ObjectUtils;

import nl.wldelft.util.Period;

import nl.wldelft.util.Properties;

import nl.wldelft.util.TextUtils;

import nl.wldelft.util.TimeZoneUtils;

import nl.wldelft.util.function.Supplier;

import nl.wldelft.util.io.VirtualOutputDir;

import nl.wldelft.util.io.VirtualOutputDirConsumer;

import nl.wldelft.util.io.XmlChunkedSerializer;

import nl.wldelft.util.timeseries.Product;

import nl.wldelft.util.timeseries.ProductInfo;

import nl.wldelft.util.timeseries.Statistics;

import nl.wldelft.util.timeseries.TimeSeriesContent;

import nl.wldelft.util.timeseries.TimeSeriesHeader;

import nl.wldelft.util.timeseries.TimeStep;

import nl.wldelft.util.timeseries.TimesOfDayDaylightSavingTimeStep;

import nl.wldelft.util.timeseries.TimesOfDayTimeStep;

import nl.wldelft.util.timeseries.TimesOfHourTimeStep;

import nl.wldelft.util.timeseries.ValueSource;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamWriter;

import java.io.IOException;

import java.io.OutputStream;

import java.nio.ByteOrder;

import java.util.Arrays;

import java.util.Locale;

import java.util.TimeZone;

public class PiTimeSeriesSerializer implements 

XmlChunkedSerializer<TimeSeriesContent>, VirtualOutputDirConsumer {

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_2 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_2);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_3 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_3);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_4 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_4);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_5 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_5);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_6 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_6);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_7 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_7);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_8 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_8);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_9 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_9);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_10 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_10);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_11 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_11);

    public static final 

Supplier<PiTimeSeriesSerializer, Error> VERSION_1_12 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_12);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_13 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_13);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_14 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_14);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_15 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_15);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_16 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_16);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_17 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_17);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_18 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_18);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_19 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_19);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_20 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_20);

  public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_21 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_21);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_22 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_22);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_23 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_23);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_24 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_24);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_25 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_25);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_26 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_26);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_27 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_27);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_28 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_28);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_29 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_29);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_30 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_30);

    public static final 

Supplier<PiTimeSeriesSerializer, 

Error> VERSION_1_31 = () -> new PiTimeSeriesSerializer(PiVersion.VERSION_1_31);

    private static final int BUFFER_SIZE = 2048;

    private TimeZone timeZone = null;

    private String missingValueText = "NaN";

    private float missingValue = Float.NaN;

    private String virtualFileName = null;

    private boolean skipEmptyTimeSeries = false;

    public void setSkipEmptyTimeSeries(boolean skipEmptyTimeSeries) {

        this.skipEmptyTimeSeries = skipEmptyTimeSeries;

    }

    public void setUseMilliseconds (boolean useMilliseconds) {this.useMilliseconds = useMilliseconds; }

    public enum EventDestination {

        XML_EMBEDDED, SEPARATE_BINARY_FILE, ONLY_HEADERS

    }

  public enum EnsembleMemberFormat {

        INDEX, ID, HIDE

    }

    private EventDestination eventDestination = EventDestination.XML_EMBEDDED;

    private PiVersion version = PiVersion.VERSION_1_2;

    private EnsembleMemberFormat ensembleMemberFormat = EnsembleMemberFormat.INDEX;

    private boolean anyTimeSeriesWritten = false;

    private FastDateFormat dateFormat = null;

    private FastDateFormat timeFormat = null;

    private boolean useMilliseconds = false;

    private TimeSeriesContent timeSeriesContent = null;

    private XMLStreamWriter writer = null;

    private VirtualOutputDir virtualOutputDir = null;

    private OutputStream binaryOutputSteam = null;

    private byte[] byteBuffer = null;

    private char[] charBuffer = null;

    private float[] floatBuffer = null;

    private int bufferPos = 0;

    private long[] cachedTimes = new long[6];

    private String[] cachedDateStrings = new String[6];

   private String[] cachedTimeStrings = new String[6];

    private int cachedSeconds = -1;

    private String cachedSecondsString = null;

    private float[][] domainAxesValues = null;

    private float[][] newDomainValues = null;

    public PiTimeSeriesSerializer() {

    }

    public PiTimeSeriesSerializer(PiVersion version) {

        this.version = version;

    }

    public void setEventDestination(EventDestination eventDestination) {

        this.eventDestination = eventDestination;

    }

    public PiVersion getVersion() {

        return version;

    }

    public void setVersion(PiVersion version) {

        Arguments.require.notNull(version);

        this.version = version;

    }

    public void setEnsembleMemberFormat(EnsembleMemberFormat ensembleMemberFormat) {

        Arguments.require.notNull(ensembleMemberFormat);

        this.ensembleMemberFormat = ensembleMemberFormat;

    }

    @Override

    public void setVirtualOutputDir(VirtualOutputDir virtualOutputDir) {

        this.virtualOutputDir = virtualOutputDir;

    }

    @Override

    public void serializeStartDocument(XMLStreamWriter streamWriter, String virtualFileName) throws Exception {

        anyTimeSeriesWritten = false;

        this.virtualFileName = virtualFileName;

        this.writer = streamWriter;

        if (ensembleMemberFormat == EnsembleMemberFormat.ID && version.getIntId() < PiVersion.VERSION_1_10.getIntId()) {

            throw new IOException("ensembleMemberId not supported for pi version " + version);

        }

        writeStartDocument();

        String binFileName = FileUtils.getPathWithOtherExtension(virtualFileName, "bin");

        if (virtualOutputDir != null) virtualOutputDir.delete(binFileName);

        if (eventDestination != EventDestination.SEPARATE_BINARY_FILE) return;

        if (virtualOutputDir == null)

            throw new IllegalStateException("virtualOutputDir == null");

        binaryOutputSteam = virtualOutputDir.getOutputStream(binFileName);

      bufferPos = 0;
        if (byteBuffer != null) return;

        byteBuffer = new byte[BUFFER_SIZE * NumberType.FLOAT_SIZE];

        floatBuffer = new float[BUFFER_SIZE];

    }

    public void writeStartDocument() throws XMLStreamException {

        writer.writeStartDocument();

        writer.writeStartElement("TimeSeries");

        writer.setDefaultNamespace("http://www.wldelft.nl/fews/PI");

        writer.writeNamespace("", "http://www.wldelft.nl/fews/PI");

        writer.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");

//        writer.writeAttribute("xmlns", "http://www.wldelft.nl/fews/PI");

        writer.writeAttribute("xsi:schemaLocation", PiSchemaLocations.get("pi_timeseries.xsd"));

        writer.writeAttribute("version", version.toString());

        if (version.getIntId() >= PiVersion.VERSION_1_19.getIntId()) {

            writer.writeAttribute("xmlns:fs", "http://www.wldelft.nl/fews/fs");

        }

    }

    @Override

    public void serializeContent(TimeSeriesContent timeSeriesContent) throws Exception {

        if (timeSeriesContent.getTimeSeriesCount() == 0) return;

        this.timeSeriesContent = timeSeriesContent;

        timeSeriesContent.setRequireEnsembleMemberIndices(ensembleMemberFormat == EnsembleMemberFormat.INDEX);

        if (!anyTimeSeriesWritten) {

       anyTimeSeriesWritten = true;
            initMissingValueText();
            initTimeZone();

            writeTimeZone();

        }

        for (int i = 0, n = timeSeriesContent.getTimeSeriesCount(); i < n; i++) {

            timeSeriesContent.setTimeSeriesIndex(i);

            if (skipEmptyTimeSeries && timeSeriesContent.isTimeSeriesEmpty()) continue;

        if (!timeSeriesContent.isTimeSeriesEmpty()) timeSeriesContent.setContentTimeIndex(0);

            writer.writeStartElement("series");

            writeHeader();

            writeEvents();

            writer.writeEndElement();

        }

    }

    @Override

    public void serializeEndDocument() throws Exception {

        if (!anyTimeSeriesWritten) throw new PiTimeSeriesNotFoundException("No TimeSeries to be Written to " + virtualFileName);

        writer.writeEndElement();

        writer.writeEndDocument();

        if (eventDestination != EventDestination.SEPARATE_BINARY_FILE) return;

        flushBinEvents();

        binaryOutputSteam.close();

        binaryOutputSteam = null;

    }

    private void initMissingValueText() {

        missingValueText = timeSeriesContent.getDefaultMissingValue('.');

        try {

            missingValue = Float.parseFloat(missingValueText);

        } catch (NumberFormatException e) {

            timeSeriesContent.setMissingValue(Float.NaN);

            missingValue = Float.NaN;

            missingValueText = "NaN";

        }

    }

    private void initTimeZone() {

        if (!ObjectUtils.equals(timeZone, this.timeSeriesContent.getDefaultTimeZone())) {

            Arrays.fill(cachedTimes, Long.MIN_VALUE);

            timeZone = timeSeriesContent.getDefaultTimeZone();

        }

        dateFormat = FastDateFormat.getInstance("yyyy-MM-dd", timeZone, Locale.US, dateFormat);

     timeFormat = useMilliseconds?FastDateFormat.getInstance("HH:mm:ss.SSS", timeZone, Locale.US, timeFormat) : FastDateFormat.getInstance("HH:mm:ss", timeZone, Locale.US, timeFormat);

    }

    private void writeTimeZone() throws XMLStreamException {

        if (timeZone.useDaylightTime()) {

            PiSerializerUtils.writeElement(writer, "daylightSavingObservingTimeZone", timeZone.getID());

        } else {

            PiSerializerUtils.writeElement(writer, "timeZone", String.valueOf(TimeZoneUtils.getTimeZoneOffsetHours(timeZone)));

        }

    }

    private void writeHeader() throws Exception {

        TimeSeriesHeader header = timeSeriesContent.getTimeSeriesHeader();

        PiTimeSeriesHeader piHeader = header instanceof PiTimeSeriesHeader ? (PiTimeSeriesHeader) header : new PiTimeSeriesHeader();

        writer.writeStartElement("header");

        PiSerializerUtils.writeElement(writer, "type", header.getParameterType() == null ? "instantaneous" : header.getParameterType().getName());

        if (version.getIntId() >= PiVersion.VERSION_1_17.getIntId() && header.getModuleInstanceId() != null) PiSerializerUtils.writeElement(writer, "moduleInstanceId", header.getModuleInstanceId());

        PiSerializerUtils.writeElement(writer, "locationId", header.getLocationId() == null ? "unknown" : header.getLocationId());

        PiSerializerUtils.writeElement(writer, "parameterId", header.getParameterId() == null ? "unknown" : header.getParameterId());

        if (version.getIntId() >= PiVersion.VERSION_1_4.getIntId()) {

            for (int i = 0, n = header.getQualifierCount(); i < n; i++) {

                PiSerializerUtils.writeElement(writer, "qualifierId", header.getQualifierId(i));

            }
        }
        if (version.getIntId() >= PiVersion.VERSION_1_4.getIntId() && header.getEnsembleId() != null && !header.getEnsembleId().equals("main")) {

            if (ensembleMemberFormat != EnsembleMemberFormat.HIDE) {

                writeOptionalElement("ensembleId", header.getEnsembleId());

                writeOptionalElement(ensembleMemberFormat == EnsembleMemberFormat.INDEX

                        ? "ensembleMemberIndex" : "ensembleMemberId", header.getEnsembleMemberId());

            }
        }

        writeTimeStep(header);
        writePeriod();
        if (version.getIntId() >= PiVersion.VERSION_1_5.getIntId()) writeTime("forecastDate", header.getForecastTime(), 2);

        if (version.getIntId() >= PiVersion.VERSION_1_20.getIntId()) writeTime("approvedDate", header.getApprovedTime(), 4);

        PiSerializerUtils.writeElement(writer, "missVal", timeSeriesContent.getDefaultMissingValue('.'));

        writeOptionalElement("longName", piHeader.getLongName());

        writeOptionalElement("stationName", header.getLocationName());

      if (version.getIntId() >= PiVersion.VERSION_1_7.getIntId()) PiSerializerUtils.writeCoordinates(writer, header, version);

        writeOptionalElement("units", header.getUnit());

        for (int i = 0, n = header.getDomainParameterCount(); i < n; i++) {

            writeDomainAxis(header.getDomainParameterId(i), header.getDomainUnit(i));

        }

        writeOptionalElement("sourceOrganisation", piHeader.getSourceOrganisation());

        writeOptionalElement("sourceSystem", piHeader.getSourceSystem());

        writeOptionalElement("fileDescription", piHeader.getFileDescription());

        if (header.getCreationTime() != Long.MIN_VALUE) {

            updateDateTimeStringCache(header.getCreationTime(), 3);

            PiSerializerUtils.writeElement(writer, "creationDate", cachedDateStrings[3]);

            PiSerializerUtils.writeElement(writer, "creationTime", cachedTimeStrings[3]);

        }

        writeOptionalElement("region", piHeader.getRegion());

        if (header.getHighLevelThresholdCount() > 0) writeHighThresholds(header);

        if (version.getIntId() >= PiVersion.VERSION_1_16.getIntId() && timeSeriesContent.hasStatistics()) writeTimeSeriesStatistics();

        if (version.getIntId() >= PiVersion.VERSION_1_26.getIntId() && timeSeriesContent.getProduct() != null) writeProduct();

        writer.writeEndElement();

    }

    private void writeProduct() throws XMLStreamException {

        Product product = timeSeriesContent.getProduct();

        writer.writeStartElement("product");

        writer.writeAttribute("id", product.getId());

        writer.writeAttribute("name", product.getName());

        writeTime("productDate", product.getProductTime(), 5);

        writer.writeEmptyElement("category");

        writer.writeAttribute("id", product.getCategory().getId());

        writer.writeAttribute("name", product.getCategory().getName());

        if (product.getProductInfos() != null && product.getProductInfos().length > 0) {

            for (int i = 0; i < product.getProductInfos().length; i++) {

                ProductInfo productInfo = product.getProductInfos()[i];

                writer.writeStartElement("productInfo");

                writer.writeStartElement("user");

                writer.writeCharacters(productInfo.getUser());

                writer.writeEndElement();

                writer.writeStartElement("confidence");

                writer.writeCharacters(productInfo.getConfidence());

                writer.writeEndElement();

                writer.writeStartElement("classification");

                writer.writeCharacters(productInfo.getClassification());

                writer.writeEndElement();

                writer.writeStartElement("comment");

                writer.writeCharacters(productInfo.getComment());

                writer.writeEndElement();

                writer.writeEndElement(); // productInfo

            }
        }
        writer.writeEndElement(); // product

    }

    private void writeTimeSeriesStatistics() throws XMLStreamException {

        Statistics timeSeriesInfoStatistics = timeSeriesContent.getStatistics();

        if (timeSeriesInfoStatistics == null) return;

        if (timeSeriesInfoStatistics.hasFirstValueTime()) writeTime("firstValueTime", timeSeriesInfoStatistics.getFirstValueTime(), 0);

      if (timeSeriesInfoStatistics.hasLastValueTime()) writeTime("lastValueTime", timeSeriesInfoStatistics.getLastValueTime(), 1);

        if (timeSeriesInfoStatistics.hasMaxValue()) PiSerializerUtils.writeElement(writer, "maxValue", timeSeriesInfoStatistics.getMaxValue('.'));

        if (timeSeriesInfoStatistics.hasMinValue()) PiSerializerUtils.writeElement(writer, "minValue", timeSeriesInfoStatistics.getMinValue('.'));

        if (timeSeriesInfoStatistics.hasValueCount()) PiSerializerUtils.writeElement(writer,"valueCount", Integer.toString(timeSeriesInfoStatistics.getValueCount()));

        if (timeSeriesInfoStatistics.hasMaxWarningLevelName()) PiSerializerUtils.writeElement(writer, "maxWarningLevelName", timeSeriesInfoStatistics.getMaxWarningLevelName());

    }

    private void writeHighThresholds(TimeSeriesHeader header) throws XMLStreamException {

        boolean thresholdsAvailable = false;

        boolean firstThreshold = true;

        for (int i = 0; i < header.getHighLevelThresholdCount(); i++) {

            TimeSeriesHeader.Threshold threshold = header.getHighLevelThreshold(i);

      String id = threshold.getId();
            String name = threshold.getName();

            //Note: here value can be NaN for LevelThresholdValues that have different values for different aggregationTimeSpans configured.

            float value = threshold.getValue();

            if (Float.isNaN(value)) {

 continue;
            }
            thresholdsAvailable = true;
            if (firstThreshold) {
                writer.writeStartElement("thresholds");
                firstThreshold = false;
            }

            if (version.getIntId() >= PiVersion.VERSION_1_14.getIntId()) {
                String label = null;
                String comment = null;
                String description = null;
                if (version.getIntId() >= PiVersion.VERSION_1_22.getIntId()){
                    label = threshold.getLabel();
                }
                if (version.getIntId() >= PiVersion.VERSION_1_27.getIntId()){
                    comment = threshold.getComment();
                    description = threshold.getDescription();
                }
                if (threshold.getGroupCount() > 0) {
                    for (int j = 0, m = threshold.getGroupCount(); j < m; j++) {
                        String groupId = threshold.getGroupId(j);
                        String groupName = threshold.getGroupName(j);
                        if (threshold.getGroupCount() == 1 && groupId != null && groupId.equalsIgnoreCase("DeprecatedThresholdsConfigured")) {
                            groupId = null;
                            groupName = null;
                        }
                        writeThreshold(id, name, value, groupId, groupName, label, description, comment);
                    }
                } else {
                    writeThreshold(id, name, value, null, null, label, description, comment);
                }
            } else {
                writeThreshold(id, name, value, null, null, null, null, null);
            }
        }

        if (thresholdsAvailable) {
            writer.writeEndElement();
        }
    }

    private void writeThreshold(String id, String name, float value, String groupId, String groupName, String label, String description, String comment) throws XMLStreamException {
        writer.writeStartElement("highLevelThreshold");
        writer.writeAttribute("id", id);
        writer.writeAttribute("name", name);
        if (label != null) writer.writeAttribute("label", label);
        if (description != null) writer.writeAttribute("description", description);
        if (comment != null) writer.writeAttribute("comment", comment);
        writer.writeAttribute("value", Float.toString(value));
        if (groupId != null) writer.writeAttribute("groupId", groupId);
        if (groupName != null) writer.writeAttribute("groupName", groupName);

        writer.writeEndElement();
    }

    private void writePeriod() throws XMLStreamException {
        TimeStep timeStep = timeSeriesContent.getTimeSeriesHeader().getTimeStep();
        Period period = timeSeriesContent.getTimeSeriesPeriod();
        Period headerPeriod;
        if (period == Period.NEVER) {
            // create a dummy period
            long now = timeStep.nearestTime(System.currentTimeMillis());
            headerPeriod = new Period(now, now);
        } else {
            headerPeriod = period;
        }

        writeTime("startDate", headerPeriod.getStartTime(), 0);
        writeTime("endDate", headerPeriod.getEndTime(), 1);
    }

    private void updateDateTimeStringCache(long time, int cacheIndex) {
        if (cachedTimes[cacheIndex] == time) return;
        cachedTimes[cacheIndex] = time;
        cachedDateStrings[cacheIndex] = dateFormat.format(time);
        cachedTimeStrings[cacheIndex] = timeFormat.format(time);
    }

    private void writeTime(String name, long time, int cacheIndex) throws XMLStreamException {
        if (time == Long.MIN_VALUE) return;
        writer.writeEmptyElement(name);

        updateDateTimeStringCache(time, cacheIndex);
        writer.writeAttribute("date", cachedDateStrings[cacheIndex]);
        writer.writeAttribute("time", cachedTimeStrings[cacheIndex]);
    }

    private void writeTimeStep(TimeSeriesHeader header) throws XMLStreamException {
        writer.writeEmptyElement("timeStep");
        TimeStep timeStep = header.getTimeStep();

        // todo add support for month time step
        if (timeStep.isEquidistantMillis()) {
            writer.writeAttribute("unit", "second");
            int seconds = (int) (timeStep.getStepMillis() / 1000);
            if (cachedSeconds != seconds) {
                cachedSecondsString = TextUtils.toString(seconds);
                cachedSeconds = seconds;
            }
            writer.writeAttribute("multiplier", cachedSecondsString);
        } else if (timeStep instanceof TimesOfDayDaylightSavingTimeStep && version.getIntId() >= PiVersion.VERSION_1_18.getIntId()) {
            writer.writeAttribute("times", PiCastorUtils.getTimesOfDayString((TimesOfDayDaylightSavingTimeStep) timeStep));
        } else if (timeStep instanceof TimesOfDayTimeStep && version.getIntId() >= PiVersion.VERSION_1_18.getIntId()) {
            writer.writeAttribute("times", PiCastorUtils.getTimesOfDayString((TimesOfDayTimeStep) timeStep));
        } else if (timeStep instanceof TimesOfHourTimeStep && version.getIntId() >= PiVersion.VERSION_1_24.getIntId()) {
            writer.writeAttribute("minutes", PiCastorUtils.getTimesOfHourString((TimesOfHourTimeStep) timeStep));
        } else {
            writer.writeAttribute("unit", "nonequidistant");
        }
    }

    private void writeEvents() throws Exception {
        switch (eventDestination) {
            case ONLY_HEADERS:
                return;
            case SEPARATE_BINARY_FILE:
                writeBinEvents();
                return;
            case XML_EMBEDDED:
                writeXmlEvents();
        }
    }

    private void writeBinEvents() throws Exception {
        for (int i = 0, n = timeSeriesContent.getContentTimeCount(); i < n; i++) {
            timeSeriesContent.setContentTimeIndex(i);
            if (!timeSeriesContent.isTimeAvailable()) continue;
            if (bufferPos == BUFFER_SIZE) flushBinEvents();
            floatBuffer[bufferPos++] = timeSeriesContent.getValue();
        }
    }

    private void flushBinEvents() throws IOException {
        if (bufferPos == 0) return;
        BinaryUtils.copy(floatBuffer, 0, bufferPos, byteBuffer, 0, bufferPos * NumberType.FLOAT_SIZE, ByteOrder.LITTLE_ENDIAN);
        binaryOutputSteam.write(byteBuffer, 0, bufferPos * NumberType.FLOAT_SIZE);
        bufferPos = 0;
    }

    private void writeXmlEvents() throws XMLStreamException {
        Properties properties = Properties.NONE;
        TimeSeriesHeader header = timeSeriesContent.getTimeSeriesHeader();
        domainAxesValues = null;
        int domainParameterCount = header.getDomainParameterCount();
        float[] floatBuffer = this.floatBuffer;
        for (int i = 0, n = timeSeriesContent.getContentTimeCount(); i < n; i++) {
            timeSeriesContent.setContentTimeIndex(i);
            if (!timeSeriesContent.isTimeAvailable()) continue;
            Properties newProperties = timeSeriesContent.getProperties();
            if (!newProperties.equals(properties)) {
                properties = newProperties;
                PiSerializerUtils.writeProperties(properties, version, writer, dateFormat, timeFormat);
            }
            boolean valueMissing = timeSeriesContent.isValueMissing();
            if (domainParameterCount > 0 && !valueMissing) {
                int valueCount = writeAxisValues();
                if (floatBuffer == null || floatBuffer.length != valueCount) {
                    floatBuffer = new float[valueCount];
                    this.floatBuffer = floatBuffer;
                }
                timeSeriesContent.readValues(floatBuffer);
            }
            if (domainParameterCount == 0 || valueMissing) {
                writer.writeEmptyElement("event");
            } else {
                writer.writeStartElement("event");
            }
            writeTime();
            if (domainParameterCount == 0) writeValue();
            PiSerializerUtils.writeFlagsUserComment(writer, timeSeriesContent, version);
            if (domainParameterCount == 0 || valueMissing) continue;
            int valuesPerRow = domainParameterCount == 1 ? 1 : domainAxesValues[1].length;
            writeValues(floatBuffer, valuesPerRow);
            writer.writeEndElement();
        }
    }

    private void writeValue() throws XMLStreamException {
        String stringValue = timeSeriesContent.getValue('.');
        writer.writeAttribute("value", stringValue);
        if (version.ordinal() >= PiVersion.VERSION_1_31.ordinal() && timeSeriesContent.getValueSource() == ValueSource.MANUAL) writer.writeAttribute("valueSource", "MAN");
        if (version.ordinal() < PiVersion.VERSION_1_23.ordinal()) return;
        if (timeSeriesContent.isValueMissing()) return;
        float value = timeSeriesContent.getValue();
        if (timeSeriesContent.getMinValue() != value) writer.writeAttribute("minValue", timeSeriesContent.getMinValue('.'));
        if (timeSeriesContent.getMaxValue() != value) writer.writeAttribute("maxValue", timeSeriesContent.getMaxValue('.'));
        if (version.ordinal() >= PiVersion.VERSION_1_29.ordinal() && !"".equals(timeSeriesContent.getDetectionSymbol())) writer.writeAttribute("detection", timeSeriesContent.getDetectionSymbol());
    }

    private void writeTime() throws XMLStreamException {
        long time = timeSeriesContent.getTime();
        String dateText = dateFormat.format(time);
        writer.writeAttribute("date", dateText);
        String timeText = timeFormat.format(time);
        writer.writeAttribute("time", timeText);
        if (version.ordinal() < PiVersion.VERSION_1_23.ordinal()) return;
        long startTime = timeSeriesContent.getRangeStartTime();
        long endTime = timeSeriesContent.getRangeEndTime();
        writeAttribute("startDate", dateFormat, startTime, time, dateText);
        writeAttribute("startTime", timeFormat, startTime, time, timeText);
        writeAttribute("endDate", dateFormat, endTime, time, dateText);
        writeAttribute("endTime" , timeFormat, endTime, time, timeText);
    }

    private void writeAttribute(String attributeName, FastDateFormat dateFormat, long time, long defaultTime, String defaultText) throws XMLStreamException {
        if (time == defaultTime) return;
        String text = dateFormat.format(time);
        if (TextUtils.equals(text, defaultText)) return;
        writer.writeAttribute(attributeName, text);
    }

    private int writeAxisValues() throws XMLStreamException {
        TimeSeriesHeader header = timeSeriesContent.getTimeSeriesHeader();
        if (domainAxesValues == null) domainAxesValues = new float[header.getDomainParameterCount()][];
        if (newDomainValues == null) newDomainValues = new float[header.getDomainParameterCount()][];
        assert !timeSeriesContent.isValueMissing();
        int res = 1;
        for (int i = 0, n = header.getDomainParameterCount(); i < n; i++) {
            float[] values = newDomainValues[i];
            int valueCount = timeSeriesContent.getDomainAxisValueCount(i);
            res *= valueCount;
            if (values == null || values.length != valueCount) {
                values = new float[valueCount];
                newDomainValues[i] = values;
            }
            timeSeriesContent.readDomainAxisValues(i, values);
            if (Arrays.equals(values, domainAxesValues[i])) continue;

            writer.writeStartElement("domainAxisValues");

            writer.writeAttribute("parameterId", header.getDomainParameterId(i));

            int valuePerRow = i =

= 0 ? 1 : values.length;
            writeValues(values, valuePerRow);

            domainAxesValues[i] = Clasz.floats.copyOfArray(values);

            writer.writeEndElement();

        }
        return res;

    }

    private void writeValues(float[] values, int valuesPerRow) throws XMLStreamException {

        assert !timeSeriesContent.isValueMissing();

        char[] buffer = this.charBuffer;

        if (buffer == null

) {
            buffer = new char[15];

            this.charBuffer = buffer;

        }
        for (int i = 0; i < values.length; i++) {

            buffer[0] = i % valuesPerRow == 0 ? '\n' : '\t';

            float value = values[i];

            int endPos;

            if (MathUtils.equals(value,

 missingValue)) {
                missingValueText.getChars(0, missingValueText.length(), buffer, 1);

                endPos = missingValueText.length() + 1;

            } else {

                endPos = TextUtils.format(buffer, 1, value, '.', 0, 10);

            }
            writer.writeCharacters(buffer,

 0, endPos);  // start with space
        }
        writer.writeCharacters("\n        ");

    }

    private void writeOptionalElement(String elementName, String s) throws XMLStreamException {

        if (s == null) return;

        if (s.trim().isEmpty()) return;

        PiSerializerUtils.writeElement(writer, elementName, s);

    }

    private void writeDomainAxis(String parameterId, String unit) throws XMLStreamException {

        writer.writeEmptyElement("domainAxis");

        writer.writeAttribute("parameterId", parameterId);

        if (unit != null) writer.writeAttribute("units", unit);

    }

}