package org.csc.phynixx.common.io;
   
   /*
    * #%L
    * phynixx-common
    * %%
    * Copyright (C) 2014 Christoph Schmidt-Casdorff
    * %%
    * 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.
   * #L%
   */
  
  
  import org.apache.commons.io.IOUtils;
  
  import java.io.ByteArrayOutputStream;
  import java.io.DataOutputStream;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  
  /**
   * Created by christoph on 12.01.14.
   */
  public class LogRecordWriter {
  
  
      private final ByteArrayOutputStream byteInput;
  
      private final DataOutputStream io;
  
      public LogRecordWriter() {
          this.byteInput = new ByteArrayOutputStream();
          this.io = new DataOutputStream(this.byteInput);
      }
  
  
      public byte[] toByteArray() throws IOException {
          this.io.flush();
          return byteInput.toByteArray();
      }
  
      public LogRecordWriter writeChar(int v) throws IOException {
          io.writeChar(v);
          return this;
      }
  
      public LogRecordWriter writeShort(int v) throws IOException {
          io.writeShort(v);
          return this;
      }
  
      public LogRecordWriter writeInt(int v) throws IOException {
          io.writeInt(v);
          return this;
      }
  
      public LogRecordWriter writeLong(long v) throws IOException {
          io.writeLong(v);
          return this;
      }
  
      public LogRecordWriter writeFloat(float v) throws IOException {
          io.writeFloat(v);
          return this;
      }
  
      public LogRecordWriter writeDouble(double v) throws IOException {
          io.writeDouble(v);
          return this;
      }
  
      public LogRecordWriter writeUTF(String str) throws IOException {
          io.writeUTF(str);
          return this;
      }
  
      public LogRecordWriter writeByte(byte b) throws IOException {
          io.writeByte(b);
          return this;
      }
  
      public LogRecordWriter writeBoolean(boolean v) throws IOException {
          io.writeBoolean(v);
          return this;
      }
  
      /**
       * write the object's class name to check the consistency if the restroe fails.
       *
      * A null object is accepted
      *
      * @param object serializable object. it has to fullfill the requirements of {@link java.io.ObjectOutputStream#writeObject(Object)} .
      * @return returns the fluent API
      * @throws IOException
      */
     public LogRecordWriter writeObject(Object object) throws IOException {
         if( object==null) {
             return this.writeNullObject();
         }
         ObjectOutputStream out=null;
         try {
             ByteArrayOutputStream byteOutput= new ByteArrayOutputStream();
             out = new ObjectOutputStream(byteOutput);
             out.writeObject(object);
             out.flush();
             byte[] serBytes=byteOutput.toByteArray();
             io.writeInt(serBytes.length);
             io.write(serBytes);
         } finally {
             if(out!=null) {
                 IOUtils.closeQuietly(out);
             }
         }
         return this;
     }
 
     /**
      * A null object is accepted
      *
      *  @return returns the fluent API
      * @throws IOException
      */
     private LogRecordWriter writeNullObject() throws IOException {
             io.writeInt(0);
             io.write(new byte[] {});
         return this;
     }
 
     public void close() {
         if (this.byteInput != null) {
             try {
                 this.io.flush();
             } catch (IOException e) {
                 // close may not fail
             }
             IOUtils.closeQuietly(this.byteInput);
         }
     }
 
 }