ElementBean.java

/**********************************************************************************
 * $URL: https://source.sakaiproject.org/svn/metaobj/trunk/metaobj-api/api/src/java/org/sakaiproject/metaobj/shared/model/ElementBean.java $
 * $Id: ElementBean.java 105079 2012-02-24 23:08:11Z ottenhoff@longsight.com $
 ***********************************************************************************
 *
 * Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009 The Sakai Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ECL-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.sakaiproject.metaobj.shared.model;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jdom.Attribute;
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
import org.sakaiproject.component.cover.ComponentManager;
import org.sakaiproject.metaobj.shared.mgt.FieldValueWrapperFactory;
import org.sakaiproject.metaobj.utils.TypedMap;
import org.sakaiproject.metaobj.utils.mvc.intf.FieldValueWrapper;
import org.sakaiproject.metaobj.utils.xml.NormalizationException;
import org.sakaiproject.metaobj.utils.xml.SchemaNode;

/**
 * Created by IntelliJ IDEA.
 * User: John Ellis
 * Date: Mar 10, 2004
 * Time: 3:45:39 PM
 * To change this template use File | Settings | File Templates.
 */
public class ElementBean extends HashMap implements TypedMap {

   protected final Log logger = LogFactory.getLog(getClass());

   private Element baseElement;
   private Map types = new HashMap();
   private SchemaNode currentSchema;
   private Map wrappedInstances = new HashMap();
   private Map wrappedLists = new HashMap();
   private boolean deferValidation = true;
   private ElementListBean parent;

   public static final String FIELD_DATA_TAG = "FIELD_DATA";

   private static FieldValueWrapperFactory wrapperFactory = null;


   public ElementBean(String elementName, SchemaNode currentSchema) {
      this.currentSchema = currentSchema;
      setBaseElement(new Element(elementName));
   }

   public ElementBean(String elementName, SchemaNode currentSchema, boolean deferValidation) {
      this.deferValidation = deferValidation;
      this.currentSchema = currentSchema;
      setBaseElement(new Element(elementName));
   }

   public ElementBean() {
      setBaseElement(new Element("empty"));
   }

   public ElementBean(Element baseElement, SchemaNode currentSchema, boolean deferValidation) {
      this.deferValidation = deferValidation;
      this.currentSchema = currentSchema;
      setBaseElement(baseElement);
   }

   public ElementBean(Element baseElement, SchemaNode currentSchema, Map wrappedInstances) {
      this.currentSchema = currentSchema;
      this.wrappedInstances = wrappedInstances;
      setBaseElement(baseElement);
   }

   public Element currentElement() {
      return baseElement;
   }

   public SchemaNode getCurrentSchema() {
      return currentSchema;
   }

   public void setCurrentSchema(SchemaNode currentSchema) {
      this.currentSchema = currentSchema;
   }

   public Object put(Object key, Object value) {
      if ( currentSchema == null ) {
         logger.debug("null schema -- ignore put for "+key);
         return null;
      }
         
      SchemaNode elementSchema = currentSchema.getChild((String) key);

      if (getWrapperFactory().checkWrapper(elementSchema.getObjectType())) {
         return this.wrappedObjectPut(key, value, elementSchema);
      }

      if (elementSchema.getMaxOccurs() == 1) {

         String normalizedValue;

         try {
            normalizedValue = elementSchema.getSchemaNormalizedValue(value);
         }
         catch (NormalizationException exp) {
            if (deferValidation) {
               normalizedValue = value.toString();
            }
            else {
               throw exp;
            }
         }

         if (elementSchema.isAttribute()) {
            Attribute oldAttribute = currentElement().getAttribute((String) key);
            if (value != null && value.toString().length() > 0) {
               logger.debug("not removing attribute" + key);
               if (oldAttribute == null) {
                  currentElement().setAttribute(key.toString(), normalizedValue);
               }
               else {
                  oldAttribute.setValue(normalizedValue);
               }
            }
            else if (oldAttribute != null) {
               logger.debug("removing attribute" + key);
               currentElement().removeAttribute(key.toString());
            }
         }
         else {
            Element oldElement = currentElement().getChild((String) key);

            if (value != null && value.toString().length() > 0) {
               if (oldElement == null) {
                  Element newElement = new Element((String) key);
                  newElement.addContent(normalizedValue);
                  currentElement().addContent(newElement);
               }
               else {
                  oldElement.setText(normalizedValue);
               }
            }
            else if (oldElement != null) {
               currentElement().removeContent(oldElement);
            }
         }
      }
      else {
         // if you got here, must be a simple element
         ElementListBean listBean = (ElementListBean) get(key);

         while (listBean.size() > 0) {
            listBean.remove(0);
         }

         if (value instanceof String[]) {

            String[] values = (String[]) value;

            for (int i = 0; i < values.length; i++) {
               if (values[i].length() > 0) {
                  ElementBean bean = listBean.createBlank();
                  bean.getBaseElement().addContent(values[i]);
                  listBean.add(bean);
               }
            }
         }
         else if (value instanceof String) {
            if (value.toString().length() > 0) {
               ElementBean bean = listBean.createBlank();
               bean.getBaseElement().addContent((String) value);
               listBean.add(bean);
            }
         }

      }

      return null;
   }

   protected FieldValueWrapperFactory getWrapperFactory() {
      if (wrapperFactory == null) {
         wrapperFactory = (FieldValueWrapperFactory) ComponentManager.getInstance().get("fieldValueWrapperFactory");
      }
      return wrapperFactory;
   }

   public static void setWrapperFactory(FieldValueWrapperFactory wrapperFactory) {
      ElementBean.wrapperFactory = wrapperFactory;
   }

   public Object remove(Object key) {
      currentElement().removeChild((String) key);
      types.remove(key);
      return null;
   }


   public Object get(Object key) {
      if ( currentSchema == null ) {
         logger.debug("null schema -- ignore get for "+key);
         return null;
      }

      SchemaNode schema = currentSchema.getChild((String) key);

      if (schema == null) {
         return null;
      }

      if (schema.getMaxOccurs() > 1 || schema.getMaxOccurs() == -1) {
         List childElements = new ArrayList();
         List rawElements = baseElement.getChildren((String) key);
         for (Iterator i = rawElements.iterator(); i.hasNext();) {
            logger.debug("got child");
            childElements.add(new ElementBean((Element) i.next(), schema, deferValidation));
         }

         if (getWrapperFactory().checkWrapper(schema.getObjectType())) {
            return wrappedListGet(childElements, schema, key);
         }
         else {
            return new ElementListBean(baseElement, childElements, schema, deferValidation);
         }
      }

      if (getWrapperFactory().checkWrapper(schema.getObjectType())) {
         return this.wrappedObjectGet(key, schema);
      }

      if (schema.isAttribute()) {
         Attribute child = baseElement.getAttribute((String) key);

         if (child == null) {
            return null;
         }
         else {
            try {
               return schema.getActualNormalizedValue(child.getValue());
            }
            catch (NormalizationException exp) {
               // This should not happen... values should already be validated...
               // just return the text itself...
               return child.getValue();
            }
         }
      }
      else {
         Element child = baseElement.getChild((String) key);

         if (child == null) {
            if (schema.getObjectType().isAssignableFrom(java.util.Map.class)) {
               child = new Element(schema.getName());
               baseElement.addContent(child);
            }
            else {
               return null;
            }
         }

         logger.debug("returning typed object");

         Class objectClass = schema.getObjectType();

         if (Map.class.isAssignableFrom(objectClass)) {
            return new ElementBean(child, schema, deferValidation);
         }
         else {
            try {
               return schema.getActualNormalizedValue(child.getText());
            }
            catch (NormalizationException exp) {
               // This should not happen... values should already be validated...
               // just return the text itself...
               return child.getText();
            }
         }
      }
   }

   protected Object wrappedListGet(List childElements, SchemaNode schema, Object key) {
      if (wrappedLists.get(key) == null) {
         wrappedLists.put(key,
            new ElementListBeanWrapper(
               new ElementListBean(baseElement, childElements, schema, deferValidation),
               (FieldValueWrapper) wrappedObjectGet(key, schema)));
      }

      return wrappedLists.get(key);
   }

   protected Object wrappedObjectPut(Object key, Object value, SchemaNode schema) {
      FieldValueWrapper wrapper = (FieldValueWrapper) wrappedInstances.get(key);

      if (wrapper == null) {
         wrapper = getWrapperFactory().wrapInstance(value);
         wrappedInstances.put(key, wrapper);
      }
      else {
         wrapper.setValue(value);
      }

      Element childElement = getBaseElement().getChild(schema.getName());

      if (childElement == null) {
         childElement = new Element(schema.getName());
         getBaseElement().addContent(childElement);
      }

      childElement.setText(schema.getSchemaNormalizedValue(value));

      return null;
   }

   protected Object wrappedObjectGet(Object key, SchemaNode schema) {
      FieldValueWrapper wrapper = (FieldValueWrapper) wrappedInstances.get(key);

      if (wrapper == null) {
         wrapper = getWrapperFactory().wrapInstance(schema.getObjectType());
         wrappedInstances.put(key, wrapper);

         Element valueElement = getBaseElement().getChild(schema.getName());

         if (valueElement != null && valueElement.getContentSize() != 0) {
            Object value = schema.getActualNormalizedValue(valueElement.getText());
            wrapper.setValue(value);
         }
      }

      return wrapper;
   }


   public Class getType(String key) {
      if ( currentSchema == null ) {
         logger.debug("null schema -- ignore getType for "+key);
         return null;
      }
      
      SchemaNode schema = currentSchema.getChild(key);

      if (schema != null) {
         if (schema.getMaxOccurs() > 1 || schema.getMaxOccurs() == -1) {
            if (getWrapperFactory().checkWrapper(schema.getObjectType())) {
               return ElementListBeanWrapper.class;
            }
            else {
               return ElementListBean.class;
            }
         }
         else {
            return schema.getObjectType();
         }
      }
      return null;
   }

   public String toString() {
      return currentElement().getText();
   }

   public void setBaseElement(Element element) {
      this.baseElement = element;
   }

   public Element getBaseElement() {
      return baseElement;
   }

   public boolean isDeferValidation() {
      return deferValidation;
   }

   public void setDeferValidation(boolean deferValidation) {
      this.deferValidation = deferValidation;
   }

   /**
    * Generate a string containing XML tags and values representing the current contents of the element
    *
    * @return An XML String representation of the object
    */
   public String toXmlString() throws PersistenceException {
      XMLOutputter outputter = new XMLOutputter();
      ByteArrayOutputStream os = new ByteArrayOutputStream();

      try {
         Format format = Format.getPrettyFormat();
         outputter.setFormat(format);
         outputter.output(getBaseElement(), os);
         return new String(os.toByteArray());
         //return os.toByteArray();
      }
      catch (IOException e) {
         throw new PersistenceException(e, "Unable to write object", null, null);
      }

   }	  // toXmlString

   class EntrySet implements Map.Entry {

      private Object key;
      private Object value;
      //TODO what about equals and hashcode?

      public EntrySet(Object key, Object value) {
         this.key = key;
         this.value = value;
      }

      /* (non-Javadoc)
       * @see java.util.Map.Entry#getKey()
       */
      public Object getKey() {
         return key;
      }

      /* (non-Javadoc)
       * @see java.util.Map.Entry#getValue()
       */
      public Object getValue() {
         return value;
      }

      /* (non-Javadoc)
       * @see java.util.Map.Entry#setValue(java.lang.Object)
       */
      public Object setValue(Object value) {
         // TODO Maybe throw an exception instead
         this.value = value;
         return this.value;
      }

   }


   /* (non-Javadoc)
    * @see java.util.Map#entrySet()
    */
   public Set entrySet() {
      Set entries = new HashSet();
      
      if ( currentSchema == null ) {
         logger.debug("null schema -- ignore entrySet");
         return entries;
      }
      
      List children = currentSchema.getChildren();
      for (Iterator iter = children.iterator(); iter.hasNext();) {
         SchemaNode child = (SchemaNode) iter.next();
         String key = child.getName();
         Object value = get(key);
         EntrySet entry = new EntrySet(key, value);
         entries.add(entry);
      }

      return entries;
   }

   /* (non-Javadoc)
    * @see java.util.Map#keySet()
    */
   public Set keySet() {
      Set keys = new HashSet();
      for (Iterator iter = entrySet().iterator(); iter.hasNext();) {
         EntrySet child = (EntrySet) iter.next();
         keys.add(child.getKey());
      }
      return keys;
   }

   /* (non-Javadoc)
    * @see java.util.Map#values()
    */
   public Collection values() {
      Set values = new HashSet();
      for (Iterator iter = entrySet().iterator(); iter.hasNext();) {
         EntrySet child = (EntrySet) iter.next();
         Object value = child.getValue();
         values.add(value);
      }
      return values;
   }

   public ElementListBean getParent() {
      return parent;
   }

   public void setParent(ElementListBean parent) {
      this.parent = parent;
   }

   public int getIndex() {
      if (parent != null) {
         return getParent().indexOf(this);
      }
      return 0;
   }

}