/*
    * Copyright 2001,2004 The Apache Software Foundation.
    * 
    * Licensed 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.scaffold.util;
  
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.beanutils.BeanUtils;
  
  import org.apache.commons.scaffold.lang.ChainedException;
  import org.apache.commons.scaffold.lang.Tokens;
  
  /**
   * Concrete implementation of ResultList.
   * @author Ted Husted
   * @version $Revision: 155464 $ $Date: 2005-02-26 13:26:54 +0000 (Sat, 26 Feb 2005) $
   */
  public class ResultListBase implements ResultList {
  
  
  // ----------------------------------------------------------- Properties
  
  
      /**
       * The result list [ArrayList].
       */
      protected List result = (List) new ArrayList();
  
  
      public List getResult() {
          return this.result;
      }
  
  
      public void setResult(List result) {
          this.result = result;
      }
  
  
  
      /**
       * Our scroller object for paging through lists.
       */
      protected Scroller scroller = null;
  
  
      public void setScroller(Scroller scroller){
          this.scroller = scroller;
      }
  
  
      public Scroller getScroller() {
          return this.scroller;
      }
  
  
      /**
       * Our intial counter value [0].
       */
      private int counter = 0;
  
  
      public int getCounter() {
          return counter++;
      }
  
  
      public void setCounter(int counter) {
             this.counter = counter;
      }
  
  
      /**
       * A result code, if returned by the resource layer.
       */
      private Integer code = null;
  
  
      public Integer getCode() {
          return (this.code);
      }
 
 
     public void setCode(Integer code) {
         this.code = code;
     }
 
 
     /**
      * A phrase describing the result list.
      * ie: field = value
      */
     private String legend = null;
 
 
     public String getLegend() {
         return (this.legend);
     }
 
 
     public void setLegend(String legend) {
         this.legend = legend;
     }
 
 
     public void setLegend(String name, String value) {
 
         if ((null==value) || ("".equals(value))) {
 
             setLegend(name + Tokens.PARAM_EQUALS + Tokens.PARAM_ANY);
 
         }
         else {
 
             setLegend(name + Tokens.PARAM_EQUALS + value);
 
         }
     }
 
 
     /**
      * The displayName map, if any.
      */
     protected Map displayName = null;
 
 
     public Map getDisplayName() {
         return this.displayName;
     }
 
 
     public void setDisplayName(Map displayName) {
         this.displayName = displayName;
     }
 
 
 
 // ------------------------------------------------------------- List Methods
 
 
     // ----- array operations -----
 
 
     public Object[] toArray() {
         return getResult().toArray();
     }
 
 
     public Object[] toArray(Object a[]) {
         return getResult().toArray(a);
     }
 
 
     // ----- basic operations -----
 
 
     public boolean isEmpty() {
         return getResult().isEmpty();
     }
 
 
     public int size() {
         return getResult().size();
     }
 
 
     public boolean contains(Object element) {
         return getResult().contains(element);
     }
 
 
     public boolean add(Object o) {
         return getResult().add(o);
     }
 
 
     public Iterator iterator() {
         return getResult().iterator();
     }
 
 
     // ----- list operations -----
 
 
     public Object get(int index) {
         return getResult().get(index);
     }
 
 
     // ----- bulk operations ------
 
 
     public boolean addAll(Collection c) {
         return getResult().addAll(c);
     }
 
 
     public void clear() {
         getResult().clear();
     }
 
 
     public boolean containsAll(Collection c) {
         return getResult().containsAll(c);
     }
 
 
     public boolean remove(Object o) {
         return getResult().remove(o);
     }
 
 
     public boolean removeAll(Collection c) {
         return getResult().removeAll(c);
     }
 
 
     public boolean retainAll(Collection c) {
         return getResult().retainAll(c);
     }
 
 
 
 // ----------------------------------------------------------- Public Methods
 
 
     public Object getElement(int index) {
         return getResult().get(index);
     }
 
 
     public Iterator getIterator() {
         return iterator();
     }
 
 
     public int getSize() {
         return size();
     }
 
 
     public boolean populate(Object o, int index) throws Exception {
         Object bean = null;
         if (size()>index)
             bean = get(index);
         if (bean==null) return false;
         try {
             BeanUtils.copyProperties(o,bean);
         } catch (Throwable t) {
             throw new ChainedException(t);
         }
         return true;
     }
 
 
 // ----------------------------------------------------------- Constructors
 
 
     /**
      * Default constructor.
      */
     public ResultListBase() {
         super();
     }
 
 
     /**
      * Convenience constructor to populate result with an element.
      */
     public ResultListBase(Object o) {
         super();
         add(o);
     }
 
 
     /**
      * Convenience constructor to populate result with a Collection.
      */
     public ResultListBase(Collection c) {
         super();
         addAll(c);
     }
 
 }