RELEASE_2_1_13/src/blocks/forms/java/org/apache/cocoon/forms/util/ContainerWidgetAsMap.java - cocoon - Git at Google

 /*
  * 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.cocoon.forms.util;

 import java.util.AbstractMap;
 import java.util.AbstractSet;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 import org.apache.cocoon.forms.formmodel.AbstractContainerWidget;
 import org.apache.cocoon.forms.formmodel.ContainerWidget;
 import org.apache.cocoon.forms.formmodel.Repeater;
 import org.apache.cocoon.forms.formmodel.Widget;
 import org.apache.commons.collections.iterators.AbstractIteratorDecorator;

 /**
  * A <code>Map</code> view of a container widget, keys being children names and values either
  * maps (for container children), objects (for terminal children) or lists (for repeaters).
  * <p>
  * The returned map is non-modifiable, except using the <code>put()</code> method, which much
  * refer to an existing child widget, and <code>putAll(Map)</code> that will silently ignore keys
  * that don't refer to existing child widgets.
  * <p>
  * Also, this map accepts getting and setting values for keys that correspond to value-less widgets
  * such as {@link org.apache.cocoon.forms.formmodel.Action}. The result in that case is always
  * <code>null</code>. This is to allow global retrieving or filling of the map values.
  *
  * @since 2.1.8
  * @version $Id$
  */
 public class ContainerWidgetAsMap extends AbstractMap {
     protected AbstractContainerWidget container;
     private boolean lowerCase;

     /**
      * Wraps a container widget in a <code>Map</code>.
      * <p>
      * The <code>keysToLowerCase</code> argument specifies if input keys given in <code>get()</code>,
      * <code>put()</code> and <code>putAll()</code> should be converted to lower case before searching for
      * the corresponding widget. This feature allows to directly feed widgets with <code>Map</code>s coming
      * from JDBC resultset rows where keys are uppercase (see <a href="http://jdbi.codehaus.org">JDBI</a>).
      *
      * @param container the container to wrap
      * @param keysToLowerCase should we convert keys to lower case?
      */
     public ContainerWidgetAsMap(AbstractContainerWidget container, boolean keysToLowerCase) {
         this.container = container;
         this.lowerCase = keysToLowerCase;
     }

     /**
      * Same as <code>ContainerWidgetAsMap(container, false)</code>
      */
     public ContainerWidgetAsMap(AbstractContainerWidget container) {
         this(container, false);
     }

     /**
      * Get the container widget that is wrapped by this <code>Map</code>.
      *
      * @return the wrapped {@link ContainerWidget}
      */
     public ContainerWidget getWidget() {
         return this.container;
     }

     /**
      * Get a widget relative to the container wrapped by this <code>Map</code>
      *
      * @param path a widget lookup path
      * @return the widget pointed to by <code>path</code> or <code>null</code> if it doesn't exist.
      * @see Widget#lookupWidget(String)
      */
     public Widget getWidget(String path) {
         return this.container.lookupWidget(path);
     }

     /**
      * Put a value in a child widget. The value must be compatible with the datatype
      * expected by the child widget. In the case of repeaters and containers, this
      * datatype is <code>Collection</code> and <code>Map</code> respectively, which
      * will be used to fill the rows and child widgets.
      * <p>
      * Note also that the contract of <code>put</code> requires the previous value
      * to be returned. In the case of repeaters and containers, the value is a live
      * wrapper around the actual widget, meaning that it's not different from the
      * current value.
      */
     public Object put(Object key, Object value) {
         String name = (String)key;
         if (lowerCase) name = name.toLowerCase();

         Widget w = container.getChild(name);
         if (w != null) {
             return setValue(w, value);
         } else {
             throw new UnsupportedOperationException(container + " has no child named '" + key + "'");
         }
     }

     public void putAll(Map map) {
         Iterator iter = map.entrySet().iterator();
         while(iter.hasNext()) {
             Map.Entry entry = (Map.Entry)iter.next();
             String name = (String)entry.getKey();
             if (lowerCase) name = name.toLowerCase();
             Widget w = container.getChild(name);
             if (w != null) {
                 setValue(w, entry.getValue());
             }
         }
     }

     public Object get(Object key) {
         String name = (String)key;
         if (lowerCase) name = name.toLowerCase();
         Widget w = container.getChild(name);
         return w == null ? null : asValueOrMap(w);
     }

     public Set entrySet() {
         return new ContainerEntrySet();
     }

     private Object asValueOrMap(Widget w) {
         if (w instanceof Repeater) {
             return new RepeaterAsList((Repeater)w, lowerCase);
         } else if (w instanceof AbstractContainerWidget) {
             return new ContainerWidgetAsMap((AbstractContainerWidget)w, lowerCase);
         } else {
             try {
                 return w.getValue();
             } catch (UnsupportedOperationException uoe) {
                 // This widget doesn't hold a value
                 return null;
             }
         }
     }

     /**
      * Set a widget's value and returns the previous value as required by put().
      */
     private Object setValue(Widget w, Object value) {
         if (w instanceof Repeater) {
             // Must be a collection
             if (!(value instanceof Collection)) {
                 throw new IllegalArgumentException("A repeater cannot be filled with " + value);
             }
             List result = new RepeaterAsList((Repeater)w, lowerCase);
             result.addAll((Collection)value);
             return result;

         } else if (w instanceof AbstractContainerWidget) {
             // Must be a map
             if (!(value instanceof Map)) {
                 throw new IllegalArgumentException("A container cannot be filled with " + value);
             }
             Map result = new ContainerWidgetAsMap((AbstractContainerWidget)w);
             result.putAll((Map)value);
             return result;
         } else {
             try {
                 Object result = w.getValue();
                 w.setValue(value);
                 return result;
             } catch (UnsupportedOperationException uoe) {
                 // This widget doesn't hold a value
                 return null;
             }
         }
     }

     private class ContainerEntrySet extends AbstractSet {
         public Iterator iterator() {
             return new ContainerEntryIterator();
         }

         public int size() {
             return container.getSize();
         }
     }

     private class ContainerEntryIterator extends AbstractIteratorDecorator {
         public ContainerEntryIterator() {
             super(container.getChildren());
         }

         public Object next() {
             return new ContainerEntry((Widget)super.next());
         }
     }

     private class ContainerEntry implements Map.Entry {
         Widget widget;
         public ContainerEntry(Widget w) {
             widget = w;
         }
         public Object getKey() {
             return widget.getName();
         }
         public Object getValue() {
             return asValueOrMap(widget);
         }
         public Object setValue(Object value) {
             Object result = asValueOrMap(widget);
             ContainerWidgetAsMap.this.setValue(widget, value);
             return result;
         }
     }
 }
	/*
	* 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.cocoon.forms.util;

	import java.util.AbstractMap;
	import java.util.AbstractSet;
	import java.util.Collection;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	import org.apache.cocoon.forms.formmodel.AbstractContainerWidget;
	import org.apache.cocoon.forms.formmodel.ContainerWidget;
	import org.apache.cocoon.forms.formmodel.Repeater;
	import org.apache.cocoon.forms.formmodel.Widget;
	import org.apache.commons.collections.iterators.AbstractIteratorDecorator;

	/**
	* A <code>Map</code> view of a container widget, keys being children names and values either
	* maps (for container children), objects (for terminal children) or lists (for repeaters).
	* <p>
	* The returned map is non-modifiable, except using the <code>put()</code> method, which much
	* refer to an existing child widget, and <code>putAll(Map)</code> that will silently ignore keys
	* that don't refer to existing child widgets.
	* <p>
	* Also, this map accepts getting and setting values for keys that correspond to value-less widgets
	* such as {@link org.apache.cocoon.forms.formmodel.Action}. The result in that case is always
	* <code>null</code>. This is to allow global retrieving or filling of the map values.
	*
	* @since 2.1.8
	* @version $Id$
	*/
	public class ContainerWidgetAsMap extends AbstractMap {
	protected AbstractContainerWidget container;
	private boolean lowerCase;

	/**
	* Wraps a container widget in a <code>Map</code>.
	* <p>
	* The <code>keysToLowerCase</code> argument specifies if input keys given in <code>get()</code>,
	* <code>put()</code> and <code>putAll()</code> should be converted to lower case before searching for
	* the corresponding widget. This feature allows to directly feed widgets with <code>Map</code>s coming
	* from JDBC resultset rows where keys are uppercase (see <a href="http://jdbi.codehaus.org">JDBI</a>).
	*
	* @param container the container to wrap
	* @param keysToLowerCase should we convert keys to lower case?
	*/
	public ContainerWidgetAsMap(AbstractContainerWidget container, boolean keysToLowerCase) {
	this.container = container;
	this.lowerCase = keysToLowerCase;
	}

	/**
	* Same as <code>ContainerWidgetAsMap(container, false)</code>
	*/
	public ContainerWidgetAsMap(AbstractContainerWidget container) {
	this(container, false);
	}

	/**
	* Get the container widget that is wrapped by this <code>Map</code>.
	*
	* @return the wrapped {@link ContainerWidget}
	*/
	public ContainerWidget getWidget() {
	return this.container;
	}

	/**
	* Get a widget relative to the container wrapped by this <code>Map</code>
	*
	* @param path a widget lookup path
	* @return the widget pointed to by <code>path</code> or <code>null</code> if it doesn't exist.
	* @see Widget#lookupWidget(String)
	*/
	public Widget getWidget(String path) {
	return this.container.lookupWidget(path);
	}

	/**
	* Put a value in a child widget. The value must be compatible with the datatype
	* expected by the child widget. In the case of repeaters and containers, this
	* datatype is <code>Collection</code> and <code>Map</code> respectively, which
	* will be used to fill the rows and child widgets.
	* <p>
	* Note also that the contract of <code>put</code> requires the previous value
	* to be returned. In the case of repeaters and containers, the value is a live
	* wrapper around the actual widget, meaning that it's not different from the
	* current value.
	*/
	public Object put(Object key, Object value) {
	String name = (String)key;
	if (lowerCase) name = name.toLowerCase();

	Widget w = container.getChild(name);
	if (w != null) {
	return setValue(w, value);
	} else {
	throw new UnsupportedOperationException(container + " has no child named '" + key + "'");
	}
	}

	public void putAll(Map map) {
	Iterator iter = map.entrySet().iterator();
	while(iter.hasNext()) {
	Map.Entry entry = (Map.Entry)iter.next();
	String name = (String)entry.getKey();
	if (lowerCase) name = name.toLowerCase();
	Widget w = container.getChild(name);
	if (w != null) {
	setValue(w, entry.getValue());
	}
	}
	}

	public Object get(Object key) {
	String name = (String)key;
	if (lowerCase) name = name.toLowerCase();
	Widget w = container.getChild(name);
	return w == null ? null : asValueOrMap(w);
	}

	public Set entrySet() {
	return new ContainerEntrySet();
	}

	private Object asValueOrMap(Widget w) {
	if (w instanceof Repeater) {
	return new RepeaterAsList((Repeater)w, lowerCase);
	} else if (w instanceof AbstractContainerWidget) {
	return new ContainerWidgetAsMap((AbstractContainerWidget)w, lowerCase);
	} else {
	try {
	return w.getValue();
	} catch (UnsupportedOperationException uoe) {
	// This widget doesn't hold a value
	return null;
	}
	}
	}

	/**
	* Set a widget's value and returns the previous value as required by put().
	*/
	private Object setValue(Widget w, Object value) {
	if (w instanceof Repeater) {
	// Must be a collection
	if (!(value instanceof Collection)) {
	throw new IllegalArgumentException("A repeater cannot be filled with " + value);
	}
	List result = new RepeaterAsList((Repeater)w, lowerCase);
	result.addAll((Collection)value);
	return result;

	} else if (w instanceof AbstractContainerWidget) {
	// Must be a map
	if (!(value instanceof Map)) {
	throw new IllegalArgumentException("A container cannot be filled with " + value);
	}
	Map result = new ContainerWidgetAsMap((AbstractContainerWidget)w);
	result.putAll((Map)value);
	return result;
	} else {
	try {
	Object result = w.getValue();
	w.setValue(value);
	return result;
	} catch (UnsupportedOperationException uoe) {
	// This widget doesn't hold a value
	return null;
	}
	}
	}

	private class ContainerEntrySet extends AbstractSet {
	public Iterator iterator() {
	return new ContainerEntryIterator();
	}

	public int size() {
	return container.getSize();
	}
	}

	private class ContainerEntryIterator extends AbstractIteratorDecorator {
	public ContainerEntryIterator() {
	super(container.getChildren());
	}

	public Object next() {
	return new ContainerEntry((Widget)super.next());
	}
	}

	private class ContainerEntry implements Map.Entry {
	Widget widget;
	public ContainerEntry(Widget w) {
	widget = w;
	}
	public Object getKey() {
	return widget.getName();
	}
	public Object getValue() {
	return asValueOrMap(widget);
	}
	public Object setValue(Object value) {
	Object result = asValueOrMap(widget);
	ContainerWidgetAsMap.this.setValue(widget, value);
	return result;
	}
	}
	}