content: /*
   * CDDL HEADER START
   *
   * The contents of this file are subject to the terms of the Common Development
   * and Distribution License (the "License").
   * You may not use this file except in compliance with the License.
   *
   * You can obtain a copy of the license at
   * src/com/vodafone360/people/VODAFONE.LICENSE.txt or
   * http://github.com/360/360-Engine-for-Android
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * When distributing Covered Code, include this CDDL HEADER in each file and
   * include the License file at src/com/vodafone360/people/VODAFONE.LICENSE.txt.
   * If applicable, add the following below this CDDL HEADER, with the fields
   * enclosed by brackets "[]" replaced with your own identifying information:
   * Portions Copyright [yyyy] [name of copyright owner]
   *
   * CDDL HEADER END
   *
   * Copyright 2010 Vodafone Sales & Services Ltd.  All rights reserved.
   * Use is subject to license terms.
   */
  
  package com.vodafone360.people.engine.content;
  
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.Queue;
  
  /**
   * Simple first in first out queue. Basically same as a LinkedList only without
   * allowing null objects.
   */
  public class FiFoQueue implements Queue<ContentObject> {
  
      /**
       * LinkedList to perform all the operations. Most methods in this class just
       * call methods on this list.
       */
      private LinkedList<ContentObject> list = new LinkedList<ContentObject>();
  
      /**
       * @see LinkedList.element()
       */
      @Override
      public final synchronized ContentObject element() {
          return list.element();
      }
  
      /**
       * Calls LinkedList.offer(Object) if content is not null.
       * 
       * @param content ContentObject to put into the list
       */
      @Override
      public final synchronized boolean offer(final ContentObject content) {
          if (content == null) {
              throw new RuntimeException("null objects not supported");
          }
          return list.offer(content);
      }
  
      /**
       * @see LinkedList.peek()
       */
      @Override
      public final synchronized ContentObject peek() {
          return list.peek();
      }
  
      /**
       * @see LinkedList.poll()
       */
      @Override
      public final synchronized ContentObject poll() {
          return list.poll();
      }
  
      /**
       * @see LinkedList.remove()
       */
      @Override
      public final synchronized ContentObject remove() {
          return list.remove();
      }
  
      /**
       * Calls LinkedList.add(Object) if content is not null.
       * 
       * @param content The ContentObject to put into the list
       * @return true if content was not null and the insertion was successful,
       *         false otherwise
       */
      @Override
      public final synchronized boolean add(final ContentObject content) {
          if (content == null) {
              return false;
          }
          return list.add(content);
      }
  
      /**
       * Iterates over a collection and tries putting all objects into the list.
       * If one of the object is null the method will exit with false.
       * 
       * @param contentCollection to be added into the list
       * @return true if every object of the provided collection could be put into
       *         the list, false otherwise
       */
      @SuppressWarnings("unchecked")
      @Override
      public final synchronized boolean addAll(
              final Collection<? extends ContentObject> contentCollection) {
          Iterator<ContentObject> iter = (Iterator<ContentObject>)contentCollection.iterator();
          while (iter.hasNext()) {
              if (!add(iter.next())) {
                  return false;
              }
          }
          return true;
  
      }
  
      /**
       * @see LinkedList.clear()
       */
      @Override
      public final synchronized void clear() {
          list.clear();
  
      }
  
      /**
       * @see LinkedList.contains(Object)
       */
      @Override
      public final synchronized boolean contains(Object content) {
          return list.contains(content);
      }
  
      /**
       * @see LinkedList.containsAll(Collection<?>)
       */
      @Override
      public final synchronized boolean containsAll(Collection<?> contentCollection) {
          return list.containsAll(contentCollection);
      }
  
      /**
       * @see LinkedList.isEmpty();
       */
      @Override
      public final synchronized boolean isEmpty() {
          return list.isEmpty();
      }
  
      /**
       * @see LinkedList.iterator()
       */
      @Override
      public final synchronized Iterator<ContentObject> iterator() {
          return list.listIterator();
      }
  
      /**
       * @see LinkedList.remove(Object)
       */
      @Override
      public final synchronized boolean remove(final Object content) {
          return list.remove(content);
      }
  
      /**
       * @see LinkedList.removeAll(Collection<?>)
       */
      @Override
      public final synchronized boolean removeAll(final Collection<?> contentCollection) {
          return list.removeAll(contentCollection);
      }
  
      /**
       * @see LinkedList.retainAll(Collection<?>)
       */
      @Override
      public final synchronized boolean retainAll(final Collection<?> contentCollection) {
          return list.retainAll(contentCollection);
      }
  
      /**
       * @see LinkedList.size();
       */
      @Override
      public final synchronized int size() {
          return list.size();
      }
  
      /**
       * @see LinekdList.toArray();
       */
      @Override
      public final synchronized Object[] toArray() {
          return list.toArray();
      }
  
      /**
       * @see LinkedList.toArray(T[] type);
       */
      @Override
      public final synchronized <T> T[] toArray(final T[] type) {
          return list.toArray(type);
      }
  
  }
  