TextDataWriter.java

/*
 * Class:        TextDataWriter
 * Description:  Text data writer
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       David Munger 
 * @since        August 2009
 *
 *
 * 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 umontreal.ssj.util.io;
 
import java.io.*;
import java.lang.reflect.Array;

public class TextDataWriter extends CachedDataWriter {


   public final String DEFAULT_COLUMN_SEPARATOR = "\t";

   public final String DEFAULT_HEADER_PREFIX = "";
 
   protected BufferedWriter out;
 
   protected Format format;
   protected boolean withHeaders;
 
   protected String columnSeparator = DEFAULT_COLUMN_SEPARATOR;
   protected String headerPrefix = DEFAULT_HEADER_PREFIX;
 
   protected String floatFormatString = null;

   protected int getMaxFieldLength() {
      int nRows = 0;
      for (DataField f : super.getFields()) {
         if (f.isArray())
            nRows = Math.max(nRows, f.getArrayLength());
      }
      return nRows;
   }

   protected void outputAsColumns() throws IOException {
 
      if (withHeaders) {
         // output field headers
         out.write(headerPrefix);
         int iAnonymous = 0;
         boolean firstColumn = true;
         for (DataField f : super.getFields()) {
            // separator
            if (!firstColumn)
               out.write(columnSeparator);
            else
               firstColumn = false;
 
            if (f.getLabel() == null)
               // anonymous field
               out.write(String.format("_data%02d_", ++iAnonymous));
            else
               // named field
               out.write(f.getLabel());
         }
         out.write("\n");
      }
 
      int nRows = getMaxFieldLength();
 
      for (int iRow = 0; iRow < nRows; iRow++) {
         boolean firstColumn = true;
         for (DataField f : super.getFields()) {
 
            // separator
            if (!firstColumn)
               out.write(columnSeparator);
            else
               firstColumn = false;
 
            // output field data
            if (f.isArray()) {
               // field is an array, output its current entry
               if (iRow < f.getArrayLength())
                  writeFormat(Array.get(f.asObject(), iRow));
            } else {
               // field is not an array, output only in first row
               if (iRow == 0)
                  writeFormat(f.asObject());
            }
         }
         out.write("\n");
      }
   }

   protected void outputAsRows() throws IOException {
 
      int iAnonymous = 0;
 
      for (DataField f : super.getFields()) {
 
         // output field header
         if (withHeaders) {
            if (f.getLabel() == null)
               // anonymous field
               out.write(String.format("_data%02d_", ++iAnonymous));
            else
               // named field
               out.write(f.getLabel());
 
            out.write(columnSeparator);
         }
 
         // output field data
 
         if (f.isArray()) {
 
            int nCols = f.getArrayLength();
 
            for (int iCol = 0; iCol < nCols; iCol++) {
 
               // separator
               if (iCol > 0)
                  out.write(columnSeparator);
 
               writeFormat(Array.get(f.asObject(), iCol));
            }
         } else {
            writeFormat(f.asObject());
         }
 
         out.write("\n");
 
      }
   }

   protected void writeFormat(Object o) throws IOException {
      String s = null;
      if (floatFormatString != null && (o instanceof Double || o instanceof Float))
         s = String.format((java.util.Locale) null, floatFormatString, o); // pass null to avoid localization
      else
         s = o.toString();
      out.write(s);
   }


   public enum Format {
      COLUMNS, ROWS
   }

   public TextDataWriter(String filename, Format format, boolean withHeaders) throws IOException {
      this.out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename)));
      this.format = format;
      this.withHeaders = withHeaders;
   }

   public TextDataWriter(File file, Format format, boolean withHeaders) throws IOException {
      this.out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)));
      this.format = format;
      this.withHeaders = withHeaders;
   }

   public TextDataWriter(OutputStream outputStream, Format format, boolean withHeaders) throws IOException {
      this.out = new BufferedWriter(new OutputStreamWriter(outputStream));
      this.format = format;
      this.withHeaders = withHeaders;
   }

   public void setFormat(Format format) {
      this.format = format;
   }

   public void setFloatFormatString(String formatString) {
      this.floatFormatString = formatString;
   }

   public void setColumnSeparator(String columnSeparator) {
      this.columnSeparator = columnSeparator;
   }

   public void setHeaderPrefix(String headerPrefix) {
      this.headerPrefix = headerPrefix;
   }

   public void close() throws IOException {
      if (format == Format.COLUMNS)
         outputAsColumns();
      else if (format == Format.ROWS)
         outputAsRows();
      out.close();
   }
 
}