/*
    * Copyright 2013 The Netty Project
    *
    * The Netty Project 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 io.netty.util.internal;
  
  import io.netty.util.Recycler;
  import io.netty.util.Recycler.Handle;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import java.util.RandomAccess;
  
  /**
   * A simple list which is recyclable. This implementation does not allow {@code null} elements to be added.
   */
  public final class RecyclableArrayList extends ArrayList<Object> {
  
      private static final long serialVersionUID = -8605125654176467947L;
  
      private static final int DEFAULT_INITIAL_CAPACITY = 8;
  
      private static final Recycler<RecyclableArrayList> RECYCLER = new Recycler<RecyclableArrayList>() {
          @Override
          protected RecyclableArrayList newObject(Handle handle) {
              return new RecyclableArrayList(handle);
          }
      };
  
      private boolean insertSinceRecycled;
  
      /**
       * Create a new empty {@link RecyclableArrayList} instance
       */
      public static RecyclableArrayList newInstance() {
          return newInstance(DEFAULT_INITIAL_CAPACITY);
      }
  
      /**
       * Create a new empty {@link RecyclableArrayList} instance with the given capacity.
       */
      public static RecyclableArrayList newInstance(int minCapacity) {
          RecyclableArrayList ret = RECYCLER.get();
          ret.ensureCapacity(minCapacity);
          return ret;
      }
  
      private final Handle handle;
  
      private RecyclableArrayList(Handle handle) {
          this(handle, DEFAULT_INITIAL_CAPACITY);
      }
  
      private RecyclableArrayList(Handle handle, int initialCapacity) {
          super(initialCapacity);
          this.handle = handle;
      }
  
      @Override
      public boolean addAll(Collection<?> c) {
          checkNullElements(c);
          if (super.addAll(c)) {
              insertSinceRecycled = true;
              return true;
          }
          return false;
      }
  
      @Override
      public boolean addAll(int index, Collection<?> c) {
          checkNullElements(c);
          if (super.addAll(index, c)) {
              insertSinceRecycled = true;
              return true;
          }
          return false;
      }
  
      private static void checkNullElements(Collection<?> c) {
          if (c instanceof RandomAccess && c instanceof List) {
              // produce less garbage
              List<?> list = (List<?>) c;
              int size = list.size();
              for (int i = 0; i  < size; i++) {
                  if (list.get(i) == null) {
                      throw new IllegalArgumentException("c contains null values");
                 }
             }
         } else {
             for (Object element: c) {
                 if (element == null) {
                     throw new IllegalArgumentException("c contains null values");
                 }
             }
         }
     }
 
     @Override
     public boolean add(Object element) {
         if (element == null) {
             throw new NullPointerException("element");
         }
         if (super.add(element)) {
             insertSinceRecycled = true;
             return true;
         }
         return false;
     }
 
     @Override
     public void add(int index, Object element) {
         if (element == null) {
             throw new NullPointerException("element");
         }
         super.add(index, element);
         insertSinceRecycled = true;
     }
 
     @Override
     public Object set(int index, Object element) {
         if (element == null) {
             throw new NullPointerException("element");
         }
         Object old = super.set(index, element);
         insertSinceRecycled = true;
         return old;
     }
 
     /**
      * Returns {@code true} if any elements where added or set. This will be reset once {@link #recycle()} was called.
      */
     public boolean insertSinceRecycled() {
         return insertSinceRecycled;
     }
 
     /**
      * Clear and recycle this instance.
      */
     public boolean recycle() {
         clear();
         insertSinceRecycled = false;
         return RECYCLER.recycle(this, handle);
     }
 }