package org.talos.impl;

 import java.util.Arrays;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Map;

 import org.talos.Container;

 import org.talos.exception.CloneNotAllowedException;

 import org.talos.model.NamedObject;

 /**

  * Provides an implementation of the Container interface.

  * 

  * All containers in Talos implement this abstract class and inherit all the

  * basic container functionality.

  * 

  * @param <T>

  *            the type of entity the container holds

  */

 public abstract class AbstractContainer<T extends NamedObject> implements

                 Container<T> {

         protected Map<String, T> elements = new HashMap<String, T>();

         /**

          * Removes an element from the storage permanently. 

          *  

          * @param element the element that must be deleted

          */

         protected abstract void remove(T element);

         /**

          * Constructor that gets a map of elements by name. In such a map, the entry's key is the name 

          * of the entry's value

          * @param elements a map of NamedObjects by name

          * @see #AbstractContainer(Collection)

          */

         protected AbstractContainer(Map<String, T> elements) {

                 this.elements = elements;

         }

         /**

          * Constructor that gets a list of elements and builds a map of elements by name. The collection

          * is not stored.

          * 

          * @param elements a collection of elements

          * @see #AbstractContainer(Map)

          */

         protected AbstractContainer(Collection<T> elements) {

                 for (T element : elements) {

                         this.elements.put(element.getName(), element);

                 }

         }

         public void remove() {

                 for (String key : this.elements.keySet()) {

                         remove(elements.get(key));

                 }

                 elements.clear();

         }

         public boolean isEmpty() {

                 return elements.isEmpty();

         }

         public Collection<T> list() {

                 return Collections.unmodifiableCollection(this.elements.values());

         }

         public boolean contains(String name) {

                 return this.elements.containsKey(name);

         }

         public boolean containsAll(String... names) {

                 if (names != null && names.length > 0) {

                         return this.elements.keySet().containsAll(Arrays.asList(names));

                 } else {

                         throw new IllegalArgumentException("names can't be empty or null");

                 }

         }

         public T getElement(String name) {

                 return this.elements.get(name);

         }

         public int size() {

                 return elements.size();

         }

         /**

          * Gets the first element the container can find. Callers should be sure that the container only

          * contains zero or one element, unless they don't care which element comes.

          * 

          * @return the first element found in the container, or null.

          */

         protected T getFirstElement() {

                 for (T result : this.elements.values()) {

                         return result;

                 }

                 return null;

         }

         /**

          * Throws an exception if the container is not capable of the cloneAs() operation

          * 

          * @throws CloneNotAllowedException if the container has too many (or too few) elements.

          */

         protected void checkCloneAllowed() throws CloneNotAllowedException {

                 if (this.size() != 1) {

                         throw new CloneNotAllowedException(this.size());

                 }

         }

 }