/*
    * Copyright 2010-2013 smartics, Kronseder & Reiner GmbH
    *
    * 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 de.smartics.testdoc.core.adapter;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.io.OutputStream;
  
  import javax.tools.FileObject;
  
  import org.apache.commons.io.IOUtils;
  
  import de.smartics.testdoc.core.doc.UnitTestDoc;
  
  /**
   * Provides means to persist the state of collected test documentation
   * information.
   *
   * @author <a href="mailto:robert.reiner@smartics.de">Robert Reiner</a>
   * @version $Revision:591 $
   */
  public final class PersistenceUtils
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Serializes the index.
     *
     * @param instance the instance to serialize.
     * @param out the stream to write to.
     * @throws IllegalStateException if the index cannot be serialized.
     */
    public void serialize(final Object instance, final OutputStream out)
      throws IllegalStateException
    {
      ObjectOutputStream output = null;
      try
      {
        output = new ObjectOutputStream(new BufferedOutputStream(out));
        output.writeObject(instance);
      }
      catch (final IOException e)
      {
        throw new IllegalStateException("Cannot persist instance of type '"
                                        + instance.getClass().getName() + "'.", e);
      }
      finally
      {
        IOUtils.closeQuietly(output);
      }
    }
  
    /**
     * Serializes the instance to the given file.
     *
     * @param instance the instance to serialize.
     * @param file the file to write to.
     * @throws IllegalStateException if the index cannot be serialized.
     */
    public void serialize(final Object instance, final FileObject file)
     throws IllegalStateException
   {
     try
     {
       removeFile(file);
       serialize(instance, file.openOutputStream());
     }
     catch (final IOException e)
     {
       throw new IllegalStateException(
           "Cannot load instance from APT filer source output folder.", e);
     }
   }
 
   private void removeFile(final FileObject file)
   {
     try
     {
       file.delete();
     }
     catch (final IllegalStateException e)
     {
       // eclipse throws this exception, but we will ignore it.
       // We want the file to be deleted to make sure the
       // seralization process does not encounter a problem
       // because of an old file lingering around. If
       // we cannot delete it, we hope we have no problems
       // overwriting it later.
     }
   }
 
   /**
    * Serializes the test doc instance to the given file.
    *
    * @param testDoc the instance to serialize.
    * @param file the file to write to.
    * @throws IllegalStateException if the index cannot be serialized.
    */
   public void serialize(final UnitTestDoc testDoc, final File file)
     throws IllegalStateException
   {
     try
     {
       final OutputStream output = new FileOutputStream(file);
       serialize(testDoc, output);
     }
     catch (final FileNotFoundException e)
     {
       throw new IllegalStateException("Cannot write instance of type '"
                                       + testDoc.getClass().getName()
                                       + "' to file '" + file.getAbsolutePath()
                                       + "'.", e);
     }
   }
 
   /**
    * Deserializes a single object from the given stream.
    *
    * @param in the stream to read from.
    * @return the object read.
    */
   public Object deserialize(final InputStream in)
   {
     ObjectInputStream input = null;
     try
     {
       input = new ObjectInputStream(new BufferedInputStream(in));
       final Object instance = input.readObject();
       return instance;
     }
     catch (final IOException e)
     {
       throw new IllegalStateException("Cannot load instance from stream.", e);
     }
     catch (final ClassNotFoundException e)
     {
       throw new IllegalStateException(
           "Cannot find class for instance to read serialized form from stream.",
           e);
     }
     finally
     {
       IOUtils.closeQuietly(input);
     }
   }
 
   /**
    * Deserializes a single object from the given file.
    *
    * @param file the file to read from.
    * @return the object read.
    */
   public Object deserialize(final File file)
   {
     try
     {
       final InputStream input = new FileInputStream(file);
       return deserialize(input);
     }
     catch (final FileNotFoundException e)
     {
       throw new IllegalStateException("Cannot load instance from file '"
                                       + file.getAbsolutePath() + "'.", e);
     }
   }
 
   /**
    * Deserializes a single object from the given file.
    *
    * @param file the file to read from.
    * @return the object read.
    */
   public Object deserialize(final FileObject file)
   {
     try
     {
       final InputStream input = file.openInputStream();
       return deserialize(input);
     }
     catch (final IOException e)
     {
       throw new IllegalStateException("Cannot load instance from file '"
                                       + file.getName() + "'.", e);
     }
   }
 
   // --- object basics --------------------------------------------------------
 
 }