/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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 org.apache.commons.flatfile;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.Iterator;
  
  import org.apache.commons.lang3.ArrayUtils;
  
  /**
   * Implementation of common operations for an EntityCollection.
   * @version $Revision: 1301248 $ $Date: 2012-03-15 17:20:49 -0500 (Thu, 15 Mar 2012) $
   */
  public abstract class EntityCollectionSupport extends EntitySupport implements EntityCollection {
      /** Serialization version */
      private static final long serialVersionUID = 5902476686737324304L;
  
      private static final byte[] DEFAULT_DELIMITER = ArrayUtils.EMPTY_BYTE_ARRAY;
  
      private byte[] delim = DEFAULT_DELIMITER;
      private boolean delimAfter = true;
      private boolean suppressEmptyChildren = true;
  
      /**
       * {@inheritDoc}
       */
      public final synchronized int length() {
          int result = 0;
          for (Iterator<Entity> it = getChildren().iterator(); it.hasNext();) {
              Entity e = it.next();
              if (shouldSuppress(e)) {
                  continue;
              }
              result += e.length();
              if (it.hasNext() || isDelimAfter()) {
                  result += getDelim().length;
              }
          }
          return result;
      }
  
      /**
       * {@inheritDoc}
       */
      public final synchronized void readFrom(InputStream is) throws IOException {
          for (Iterator<Entity> it = getChildren().iterator(); it.hasNext();) {
              Entity e = it.next();
              if (shouldSuppress(e)) {
                  continue;
              }
              e.readFrom(is);
              if (it.hasNext() || isDelimAfter()) {
                  is.skip(getDelim().length);
              }
          }
      }
  
      /**
       * {@inheritDoc}
       */
      public final synchronized void writeTo(OutputStream os) throws IOException {
          for (Iterator<Entity> it = getChildren().iterator(); it.hasNext();) {
              Entity e = it.next();
              if (shouldSuppress(e)) {
                  continue;
              }
              e.writeTo(os);
              if (it.hasNext() || isDelimAfter()) {
                  os.write(getDelim());
              }
          }
      }
  
      /**
       * {@inheritDoc}
       */
      public final synchronized byte[] getValue() {
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          try {
              writeTo(baos);
          } catch (IOException e) {
             throw new RuntimeException(e);
         }
         return baos.toByteArray();
     }
 
     /**
      * {@inheritDoc}
      */
     public final synchronized void setValue(byte[] b) {
         try {
             readFrom(new ByteArrayInputStream(b));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public final void setValue(byte[] b, int offset, int length) {
         try {
             readFrom(new ByteArrayInputStream(b, offset, length));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
     }
 
     /**
      * Learn whether a trailing delimiter will be added when a delimiter is being used.
      * @return boolean.
      */
     public boolean isDelimAfter() {
         return delimAfter;
     }
 
     /**
      * Set whether to add a trailing delimiter when a delimiter is being used.
      * Default is <code>true</code>.
      * @param delimAfter The boolean delimAfter to set.
      */
     public void setDelimAfter(boolean delimAfter) {
         this.delimAfter = delimAfter;
     }
 
     /**
      * Get the delimiter to use between children.
      * @return byte[].
      */
     public byte[] getDelim() {
         return delim;
     }
 
     /**
      * Set the delimiter to use between children.
      * @param delim The byte[] delimiter to set.
      */
     public synchronized void setDelim(byte[] delim) {
         this.delim = delim == null ? DEFAULT_DELIMITER : delim;
     }
 
     /**
      * Get the boolean suppressEmptyChildren.
      * @return boolean
      */
     public boolean isSuppressEmptyChildren() {
         return suppressEmptyChildren;
     }
 
     /**
      * Set the boolean suppressEmptyChildren.
      * @param suppressEmptyChildren boolean
      */
     public void setSuppressEmptyChildren(boolean suppressEmptyChildren) {
         this.suppressEmptyChildren = suppressEmptyChildren;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public EntityCollectionSupport clone() {
         return (EntityCollectionSupport) super.clone();
     }
 
     /**
      * Learn whether the specified child should be suppressed.
      * @param child to check
      * @return boolean
      */
     protected boolean shouldSuppress(Entity child) {
         return isSuppressEmptyChildren() && child.length() == 0;
     }
 
 }