/*
    * 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.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  
  /**
   * Entity collection with the following approach:  a size (number of children)
   * and a prototypical child are assigned.  The prototype child is cloned
   * <code>size</code> times, and these clones become the indexed child entities.
   */
  public class EntityArray extends EntityCollectionSupport implements
          IndexedEntityCollection {
      private static final long serialVersionUID = 8716199462287161060L;
  
      private int size = -1;
      private int minimumSize = 0;
      private int maximumSize = Integer.MAX_VALUE;
      private boolean resizable = false;
      private List<Entity> children;
      private Entity prototype;
  
      /**
       * Create a new EntityArray.
       */
      public EntityArray() {
          // default constructor
      }
  
      /**
       * Create a new IndexedEntityCollection.
       * @param size number of occurrences of the prototypical Entity
       */
      public EntityArray(int size) {
          setSize(size);
      }
  
      /**
       * Create a new EntityArray with the specified prototype.
       * @param prototype Entity
       */
      public EntityArray(Entity prototype) {
          setPrototype(prototype);
      }
  
      /**
       * Create a new IndexedEntityCollection.
       * @param prototype Entity
       * @param size number of occurrences
       */
      public EntityArray(Entity prototype, int size) {
          this(prototype);
          setSize(size);
      }
  
      /**
       * {@inheritDoc}
       */
      public Entity getChild(int index) {
          initialize();
          return (Entity) children.get(index);
      }
  
      /**
       * {@inheritDoc}
       */
      public synchronized Collection<Entity> getChildren() {
          initialize();
          return Collections.unmodifiableCollection(children);
      }
  
      /**
       * Get the prototype.
       * @return Entity.
       */
      public synchronized Entity getPrototype() {
          return prototype;
      }
  
      /**
       * Set the prototype.
       * @param prototype The Entity prototype to set.
      */
     public synchronized void setPrototype(Entity prototype) {
         if (prototype == null) {
             throw new IllegalArgumentException("prototype Entity was null");
         }
         this.prototype = prototype;
     }
 
     /**
      * {@inheritDoc}
      * @throws IllegalArgumentException if <code>size</code> is not valid.
      */
     public synchronized void setSize(int size) {
         if (this.size >= 0 && !isResizable()) {
             if (size == this.size()) {
                 return;
             }
             throw new IllegalStateException("size already set");
         }
         if (size < minimumSize || size > maximumSize) {
             throw new IllegalArgumentException("illegal collection size: "
                     + size + "; should be <= " + maximumSize + " and >= "
                     + minimumSize);
         }
         this.size = size;
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized int size() {
         return size;
     }
 
     /**
      * {@inheritDoc}
      */
     public synchronized boolean isSizable() {
         return size == -1 || isResizable();
     }
 
     /**
      * Clone this EntityArray.
      * @return new EntityArray
      */
     @Override
     public synchronized EntityArray clone() {
         EntityArray result = (EntityArray) super.clone();
         if (children != null) {
             result.children = new ArrayList<Entity>();
             for (Entity e : children) {
                 result.children.add(e.clone());
             }
         }
         return result;
     }
 
     /**
      * Initialize this EntityArray.
      */
     private synchronized void initialize() {
         if (children != null) {
             return;
         }
         if (size < 0) {
             throw new IllegalStateException("EntityArray size not set");
         }
         if (size == 0) {
             children = Collections.<Entity>emptyList();
             return;
         }
         if (prototype == null) {
             throw new IllegalStateException("Prototype child entity not set");
         }
         children = new ArrayList<Entity>(size);
         adjustSize();
     }
 
     /**
      * Adjust the size of this EntityArray.
      */
     private synchronized void adjustSize() {
         if (children.size() > size) {
             children.subList(size, children.size()).clear();
             return;
         }
         for (int i = children.size(); i < size; i++) {
             children.add(prototype.clone());
         }
     }
 
     /**
      * Get the int maximumSize.
      * @return int
      */
     public synchronized int getMaximumSize() {
         return maximumSize;
     }
 
     /**
      * Set the int maximumSize.
      * @param maximumSize int
      */
     public synchronized void setMaximumSize(int maximumSize) {
         if (maximumSize > Integer.MAX_VALUE || maximumSize < getMinimumSize()) {
             throw new IllegalArgumentException(Integer.toString(maximumSize));
         }
         this.maximumSize = maximumSize;
     }
 
     /**
      * Get the int minimumSize.
      * @return int
      */
     public synchronized int getMinimumSize() {
         return minimumSize;
     }
 
     /**
      * Set the int minimumSize.
      * @param minimumSize int
      */
     public synchronized void setMinimumSize(int minimumSize) {
         if (minimumSize < 0 || minimumSize > getMaximumSize()) {
             throw new IllegalArgumentException(Integer.toString(minimumSize));
         }
         this.minimumSize = minimumSize;
     }
 
     /**
      * Get the boolean resizable.
      * @return boolean
      */
     public boolean isResizable() {
         return resizable;
     }
 
     /**
      * Set the boolean resizable.
      * @param resizable boolean
      */
     public void setResizable(boolean resizable) {
         this.resizable = resizable;
     }
 
 }