/**

  * Copyright 2005-2011 The Kuali 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/ecl2.php

  *

  * 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.kuali.rice.core.api.mo;

 import org.apache.commons.lang.builder.EqualsBuilder;

 import org.apache.commons.lang.builder.HashCodeBuilder;

 import org.apache.commons.lang.builder.ToStringBuilder;

 import org.kuali.rice.core.api.CoreConstants;

 import org.kuali.rice.core.api.util.collect.CollectionUtils;

 import javax.xml.bind.Unmarshaller;

 import javax.xml.bind.annotation.XmlTransient;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.lang.reflect.Field;

 /**

  * All model object's that are Jaxb annotated should extend this class.

  *

  * This class does several important things:

  * <ol>

  *     <li>Defines jaxb callback method to ensure that Collection and Map types are unmarshalled into immutable empty forms rather than null values</li>

  *     <li>Defines equals/hashcode/toString</li>

  *

  *     Note: the equals/hashCode implementation excludes {@value CoreConstants.CommonElements#FUTURE_ELEMENTS} field.

  *     This element should be present on all jaxb annotated classes.

  * </ol>

  *

  * <b>Important: all classes extending this class must be immutable</b>

  */

 @XmlTransient // marked as @XmlTransient so that an AbstractDataTransferObjectType is not included in all WSDL schemas

 public abstract class AbstractDataTransferObject implements ModelObjectComplete {

     private transient volatile Integer _hashCode;

     private transient volatile String _toString;

     protected AbstractDataTransferObject() {

         super();

     }

     @Override

     public int hashCode() {

         //using DCL idiom to cache hashCodes.  Hashcodes on immutable objects never change.  They can be safely cached.

         //see effective java 2nd ed. pg. 71

         Integer h = _hashCode;

         if (h == null) {

             synchronized (this) {

                 h = _hashCode;

                 if (h == null) {

                     _hashCode = h = Integer.valueOf(HashCodeBuilder.reflectionHashCode(this, Constants.HASH_CODE_EQUALS_EXCLUDE));

                 }

             }

         }

         return h.intValue();

     }

     @Override

     public boolean equals(Object obj) {

         return EqualsBuilder.reflectionEquals(obj, this, Constants.HASH_CODE_EQUALS_EXCLUDE);

     }

     @Override

     public String toString() {

         //using DCL idiom to cache toString.  toStrings on immutable objects never change.  They can be safely cached.

         //see effective java 2nd ed. pg. 71

         String t = _toString;

         if (t == null) {

             synchronized (this) {

                 t = _toString;

                 if (t == null) {

                     _toString = t = ToStringBuilder.reflectionToString(this);

                 }

             }

         }

         return t;

     }

     @SuppressWarnings("unused")

     protected void beforeUnmarshal(Unmarshaller u, Object parent) throws Exception {

     }

     @SuppressWarnings("unused")

     protected void afterUnmarshal(Unmarshaller u, Object parent) throws Exception {

         CollectionUtils.makeUnmodifiableAndNullSafe(this);

     }

     private transient Object serializationMutex = new Object();

     private void writeObject(ObjectOutputStream out) throws IOException {

         synchronized (serializationMutex) {

             clearFutureElements();

             out.defaultWriteObject();

         }

     }

     private void readObject(ObjectInputStream ois) throws IOException,

             ClassNotFoundException {

         ois.defaultReadObject();

         serializationMutex = new Object();

     }

     /**

      * Looks for a field named "_futureElements" on the class and clears it's value if it exists.  This allows us to

      * prevent from storing these values during serialization.

      */

     private void clearFutureElements() {

         try {

             Field futureElementsField = getClass().getDeclaredField(CoreConstants.CommonElements.FUTURE_ELEMENTS);

             boolean originalAccessible = futureElementsField.isAccessible();

             futureElementsField.setAccessible(true);

             try {

                 futureElementsField.set(this, null);

             } finally {

                 futureElementsField.setAccessible(originalAccessible);

             }

         } catch (NoSuchFieldException e) {

             // if the field does not exist, don't do anything

         } catch (IllegalAccessException e) {

             // can't modify the field, ignore

         }

     }

     /**

      * Defines some internal constants used on this class.

      */

     protected static class Constants {

         final static String[] HASH_CODE_EQUALS_EXCLUDE = { CoreConstants.CommonElements.FUTURE_ELEMENTS, "_hashCode", "_toString" };

     }

 }