/**
    * Copyright 2005-2016 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.krad.data.metadata.impl;
  
  import java.lang.reflect.Field;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.krad.data.metadata.DataObjectAttribute;
  import org.kuali.rice.krad.data.metadata.DataObjectAttributeRelationship;
  import org.kuali.rice.krad.data.metadata.DataObjectCollection;
  import org.kuali.rice.krad.data.metadata.DataObjectRelationship;
  import org.kuali.rice.krad.data.metadata.MetadataMergeAction;
  import org.kuali.rice.krad.data.provider.annotation.UifAutoCreateViewType;
  
  import com.google.common.annotations.Beta;
  
  /**
   * Base implementation class for the metadata related to the data object as a whole.
   *
   * <p>
   * Contains lists of all child elements.
   * </p>
   * 
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class DataObjectMetadataImpl extends MetadataCommonBase implements DataObjectMetadataInternal {
  	private static final long serialVersionUID = 7722982931510558892L;
  
  	protected DataObjectMetadataInternal embedded;
  	/**
  	 * Property used to help with debugging.
  	 * 
  	 * It is used in the toString() method so you can determine from which provider this metadata was extracted.
  	 */
  	protected String providerName;
  
  	protected Class<?> type;
  
  	protected List<DataObjectAttribute> attributes;
  	protected Map<String, DataObjectAttribute> attributeMap;
  	protected List<String> removedAttributeNames;
  	protected List<String> orderedAttributeList = new ArrayList<String>();
  
  	protected List<DataObjectCollection> collections;
  	protected Map<String, DataObjectCollection> collectionMap;
  	protected List<String> removedCollectionNames;
  
  	protected List<DataObjectRelationship> relationships;
  	protected Map<String, DataObjectRelationship> relationshipMap;
  	protected List<String> removedRelationshipNames;
  
  	protected Map<String, List<DataObjectRelationship>> attributeToRelationshipMap;
  	protected Map<String, DataObjectRelationship> lastAttributeToRelationshipMap;
  
  	protected List<String> primaryKeyAttributeNames;
  	protected List<String> businessKeyAttributeNames;
  	protected String primaryDisplayAttributeName;
  	protected boolean primaryDisplayAttributeSetManually;
  
  	protected Boolean supportsOptimisticLocking;
  
  	protected Collection<UifAutoCreateViewType> autoCreateUifViewTypes;
  
  	public DataObjectMetadataImpl() {
  	}
  
      /**
      * {@inheritDoc}
      */
  	@Override
  	public Object getUniqueKeyForMerging() {
  		return type;
  	}
  
      /**
      * {@inheritDoc}
      */
  	@Override
  	public Class<?> getType() {
  		return type;
 	}
 
     /**
     * Sets unknown class to determine type.
     *
     * @param type unknown class
     */
 	public void setType(Class<?> type) {
 		if (type == null) {
 			throw new IllegalArgumentException("The data object type may not be set to null.");
 		}
 		this.type = type;
 	}
 
     /**
     * Gets type based on unknown class.
     *
     * @return class type or null
     */
 	public String getTypeClassName() {
 		if (type == null) {
 			return null;
 		}
 		return type.getName();
 	}
 
 	/**
 	 * This is really a helper method for cases where these objects may need to be built up via Spring XML.
      *
      * @param typeClassName class type
 	 */
 	public void setTypeClassName(String typeClassName) {
         try {
 			setType(Class.forName(typeClassName));
         } catch (ClassNotFoundException e) {
             throw new IllegalArgumentException("ClassNotFoundException when setting data object type class name "
 					+ typeClassName, e);
         }
     }
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public List<String> getPrimaryKeyAttributeNames() {
 		if (primaryKeyAttributeNames != null) {
 			return primaryKeyAttributeNames;
 		}
 
 		if (embedded != null) {
 			return embedded.getPrimaryKeyAttributeNames();
 		}
 
 		return Collections.emptyList();
 	}
 
     /**
     * Sets list of primary attribute names which make up key.
     *
     * @param primaryKeyAttributeNames list of attribute names.
     */
 	public void setPrimaryKeyAttributeNames(List<String> primaryKeyAttributeNames) {
 		if (primaryKeyAttributeNames == null) {
 			primaryKeyAttributeNames = Collections.emptyList();
 		}
 
 		this.primaryKeyAttributeNames = Collections.unmodifiableList( primaryKeyAttributeNames );
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public List<String> getBusinessKeyAttributeNames() {
 		// If we have business keys, use that
 		if (businessKeyAttributeNames != null) {
 			return businessKeyAttributeNames;
 		}
 
 		// Otherwise, if we have an explicit PK, use that
 		if (primaryKeyAttributeNames != null) {
 			return primaryKeyAttributeNames;
 		}
 
 		// If neither has been set, go up the chain
 		if (embedded != null) {
 			return embedded.getBusinessKeyAttributeNames();
 		}
 
 		return Collections.emptyList();
 	}
 
     /**
     * Sets list of attribute names that make up business key.
     *
     * @param businessKeyAttributeNames attribute names
     */
 	public void setBusinessKeyAttributeNames(List<String> businessKeyAttributeNames) {
 		if (businessKeyAttributeNames == null) {
 			businessKeyAttributeNames = Collections.emptyList();
 		}
 
 		this.businessKeyAttributeNames = Collections.unmodifiableList(businessKeyAttributeNames);
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public Boolean hasDistinctBusinessKey() {
 		return !getPrimaryKeyAttributeNames().equals(getBusinessKeyAttributeNames());
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public String getPrimaryDisplayAttributeName() {
 		if (primaryDisplayAttributeName == null && !getBusinessKeyAttributeNames().isEmpty()) {
 			primaryDisplayAttributeName = getBusinessKeyAttributeNames().get(getBusinessKeyAttributeNames().size() - 1);
 		}
 
 		return primaryDisplayAttributeName;
 		// Notes for potential use cases if deemed necessary to implement.
 		// Since the last field of the PK does not generally change between
 		// metadata layers, these cases may not need to be considered.
 		// CASES:
 		// 1) primaryDisplayAttributeName != null ==> primaryDisplayAttributeName
 		// 2) primaryDisplayAttributeName == null && pk fields == null/empty && embedded != null ==>
 		// embedded.getprimaryDisplayAttributeName()
 		// 3) primaryDisplayAttributeName == null && pk fields == null/empty && embedded == null ==> null
 		// 4) primaryDisplayAttributeName == null && pk fields != null/empty && embedded == null ==> last field of PK
 		// 5) primaryDisplayAttributeName == null && pk fields != null/empty && embedded != null && embedded.primary
 		// display == null ==> last field of PK
 		// 6) primaryDisplayAttributeName == null && pk fields != null/empty && embedded != null && embedded.primary
 		// display != null ==> embedded.getprimaryDisplayAttributeName()
 		// If not set locally
 		// need to check embedded
 		// But - embedded could be dynamically or manually set as well
 		// how do we detect whether it's been set explicitly on the embedded? If we don't, then we always get the last
 		// attribute of the PK list on the embedding object
 	}
 
     /**
     * Sets list of attribute names used for display.
     *
     * @param primaryDisplayAttributeName list of attribute names.
     */
 	public void setPrimaryDisplayAttributeName(String primaryDisplayAttributeName) {
 		if (StringUtils.isBlank(primaryDisplayAttributeName)) {
 			this.primaryDisplayAttributeName = null;
 			this.primaryDisplayAttributeSetManually = false;
 		} else {
 			this.primaryDisplayAttributeName = primaryDisplayAttributeName;
 			this.primaryDisplayAttributeSetManually = true;
 		}
 	}
 
     /**
     * Orders attributes by defined order.
     *
     * <p>
     *     First looks to see if attributes are inherited, then looks at the declared fields based on the attribute
     *     type.
     * </p>
     *
     * @param attributes list of data object attributes
     * @return re-ordered list of data object attributes
     */
 	public List<DataObjectAttribute> orderAttributesByDefinedOrder(List<DataObjectAttribute> attributes) {
 		List<DataObjectAttribute> sorted = new ArrayList<DataObjectAttribute>(attributes.size());
 		Map<String, DataObjectAttribute> keyedAttributes = new HashMap<String, DataObjectAttribute>(attributes.size());
 		Map<String, List<DataObjectAttribute>> inheritedAttributes = new HashMap<String, List<DataObjectAttribute>>();
 
 		for (DataObjectAttribute attr : attributes) {
 			if (attr.isInherited()) {
 				List<DataObjectAttribute> inheritedByProperty = inheritedAttributes.get(attr
 						.getInheritedFromParentAttributeName());
 
 				if (inheritedByProperty == null) {
 					inheritedByProperty = new ArrayList<DataObjectAttribute>();
 					inheritedAttributes.put(attr.getInheritedFromParentAttributeName(), inheritedByProperty);
 				}
 
 				inheritedByProperty.add(attr);
 			} else {
 				keyedAttributes.put(attr.getName(), attr);
 			}
 		}
 
 		for (Field f : getType().getDeclaredFields()) {
 			DataObjectAttribute attr = keyedAttributes.get(f.getName());
 
 			if (attr != null) {
 				sorted.add(attr);
 				keyedAttributes.remove(f.getName());
 			}
 
 			if (inheritedAttributes.containsKey(f.getName())) {
 				sorted.addAll(inheritedAttributes.get(f.getName()));
 			}
 		}
 		sorted.addAll(keyedAttributes.values());
 		return sorted;
 	}
 
 	List<DataObjectAttribute> mergedAttributes = null;
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public List<DataObjectAttribute> getAttributes() {
 		// We have a local list and no overrides - return the existing list
 		if (attributes != null && embedded == null) {
 			return orderAttributesByDefinedOrder(attributes);
 		}
 
 		if (embedded != null) {
 			return orderAttributesByDefinedOrder(mergeLists(embedded.getAttributes(), attributes));
 		}
 
 		return Collections.emptyList();
 	}
 
     /**
     * Sets attributes.
      *
      * <p>
      *     Looks at merge actions when adding, so not all attributes are added.
      * </p>
     *
     * @param attributes list of data object attributes
     */
 	public void setAttributes(List<DataObjectAttribute> attributes) {
 		if (attributes == null) {
 			attributes = Collections.emptyList();
 		}
 
 		this.attributes = Collections.unmodifiableList(attributes);
 		mergedAttributes = null;
 		attributeMap = new HashMap<String, DataObjectAttribute>(attributes.size());
 		removedAttributeNames = new ArrayList<String>();
 		for (DataObjectAttribute attr : attributes) {
 			// TODO: This is not quite correct - we really only want to not add the NO_OVERRIDE items if they are
 			// overriding something. However, at the point this is running, we don't know whether we will be embedding
 			// anything...
 			if (attr.getMergeAction() != MetadataMergeAction.REMOVE
 					&& attr.getMergeAction() != MetadataMergeAction.NO_OVERRIDE) {
 				attributeMap.put(attr.getName(), attr);
 			}
 
 			// since the attribute will still exist in the embedded metadata, we need to put a block in on the standard
 			// cascade
 			if (attr.getMergeAction() == MetadataMergeAction.REMOVE) {
 				removedAttributeNames.add(attr.getName());
 			}
 		}
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public List<DataObjectCollection> getCollections() {
 		// We have a local list and no overrides - return the existing list
 		if (collections != null && embedded == null) {
 			return collections;
 		}
 
 		if (embedded != null) {
 			return mergeLists(embedded.getCollections(), collections);
 		}
 
 		return Collections.emptyList();
 	}
 
     /**
     * Sets collections.
     *
     * <p>
     *     Looks at merge actions when adding, so not all collections are added.
     * </p>
     *
     * @param collections list of data object collections or null
     */
 	public void setCollections(List<DataObjectCollection> collections) {
 		if (collections == null) {
 			this.collections = null;
 			return;
 		}
 
 		this.collections = Collections.unmodifiableList(collections);
 		collectionMap = new HashMap<String, DataObjectCollection>(collections.size());
 		removedCollectionNames = new ArrayList<String>();
 		for (DataObjectCollection coll : collections) {
 			// This is not quite correct - we really only want to not add the NO_OVERRIDE items if they are
 			// overriding something. However, at the point this is running, we don't know whether we will be embedding
 			// anything...
 			if (coll.getMergeAction() != MetadataMergeAction.REMOVE
 					&& coll.getMergeAction() != MetadataMergeAction.NO_OVERRIDE) {
 				collectionMap.put(coll.getName(), coll);
 			}
 
 			// since the attribute will still exist in the embedded metadata, we need to put a block in on the standard
 			// cascade
 			if (coll.getMergeAction() == MetadataMergeAction.REMOVE) {
 				removedCollectionNames.add(coll.getName());
 			}
 		}
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public List<DataObjectRelationship> getRelationships() {
 		// We have a local list and no overrides - return the existing list
 		if (relationships != null && embedded == null) {
 			return relationships;
 		}
 
 		if (embedded != null) {
 			return mergeLists(embedded.getRelationships(), relationships);
 		}
 
 		return Collections.emptyList();
 	}
 
     /**
     * Sets relationships.
     *
     * <p>
     *     Looks at merge actions and whether the relationship is empty when adding, so not all relationships are added.
     * </p>
     *
     * @param relationships list of data object relationships or null
     */
 	public void setRelationships(List<DataObjectRelationship> relationships) {
 		if (relationships == null) {
 			this.relationships = null;
 			relationshipMap = null;
 			lastAttributeToRelationshipMap = null;
 			attributeToRelationshipMap = null;
 			return;
 		}
 
 		this.relationships = Collections.unmodifiableList(relationships);
 		relationshipMap = new HashMap<String, DataObjectRelationship>(relationships.size());
 		attributeToRelationshipMap = new HashMap<String, List<DataObjectRelationship>>();
 		lastAttributeToRelationshipMap = new HashMap<String, DataObjectRelationship>(relationships.size());
 		removedRelationshipNames = new ArrayList<String>();
 
 		// Builds maps to link attribute names to their relationships
 		for (DataObjectRelationship rel : relationships) {
 			// This is not quite correct - we really only want to not add the NO_OVERRIDE items if they are
 			// overriding something. However, at the point this is running, we don't know whether we will be embedding
 			// anything...
 			if (rel.getMergeAction() != MetadataMergeAction.REMOVE
 					&& rel.getMergeAction() != MetadataMergeAction.NO_OVERRIDE) {
 				// related object attribute name
 				relationshipMap.put(rel.getName(), rel);
 
 				// last attribute in list linking the objects
 				if (!rel.getAttributeRelationships().isEmpty()) {
 					DataObjectAttributeRelationship relAttr = rel.getAttributeRelationships().get(
 							rel.getAttributeRelationships().size() - 1);
 					lastAttributeToRelationshipMap.put(relAttr.getParentAttributeName(), rel);
 				}
 
 				// all relationships relating to an attribute
 				for (DataObjectAttributeRelationship relAttr : rel.getAttributeRelationships()) {
 					List<DataObjectRelationship> rels = attributeToRelationshipMap
 							.get(relAttr.getParentAttributeName());
 					if (rels == null) {
 						rels = new ArrayList<DataObjectRelationship>();
 						attributeToRelationshipMap.put(relAttr.getParentAttributeName(), rels);
 					}
 					rels.add(rel);
 				}
 			}
 
 			// since the attribute will still exist in the embedded metadata, we need to put a block in on the standard
 			// cascade
 			if (rel.getMergeAction() == MetadataMergeAction.REMOVE) {
 				removedRelationshipNames.add(rel.getName());
 			}
 		}
 		relationshipMap = Collections.unmodifiableMap(relationshipMap);
 		lastAttributeToRelationshipMap = Collections.unmodifiableMap(lastAttributeToRelationshipMap);
 		attributeToRelationshipMap = Collections.unmodifiableMap(attributeToRelationshipMap);
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public DataObjectAttribute getAttribute(String attributeName) {
 		if (attributeName == null) {
 			return null;
 		}
 
 		DataObjectAttribute attribute = null;
 
 		// attempt to get it from the local attribute map (if any attributed defined locally)
 		if (attributes != null) {
 			attribute = attributeMap.get(attributeName);
 		}
 
 		// if we don't find one, but we have an embedded metadata object, check it
 		if (attribute == null && embedded != null) {
 			attribute = embedded.getAttribute(attributeName);
 			// but, ensure it's not on the removed attribute list
 			if (attribute != null && removedAttributeNames != null
 					&& removedAttributeNames.contains(attribute.getName())) {
 				attribute = null;
 			}
 		}
 
 		return attribute;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public DataObjectCollection getCollection(String collectionName) {
 		if (collectionName == null) {
 			return null;
 		}
 
 		DataObjectCollection collection = null;
 
 		// attempt to get it from the local attribute map (if any attributed defined locally)
 		if (collections != null) {
 			collection = collectionMap.get(collectionName);
 		}
 
 		// if we don't find one, but we have an embedded metadata object, check it
 		if (collection == null && embedded != null) {
 			collection = embedded.getCollection(collectionName);
 			// but, ensure it's not on the removed attribute list
 			if (collection != null && removedCollectionNames != null
 					&& removedCollectionNames.contains(collection.getName())) {
 				collection = null;
 			}
 		}
 
 		return collection;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public DataObjectRelationship getRelationship(String relationshipName) {
 		if (relationshipName == null) {
 			return null;
 		}
 
 		DataObjectRelationship relationship = null;
 
 		// attempt to get it from the local attribute map (if any attributed defined locally)
 		if (relationships != null) {
 			relationship = relationshipMap.get(relationshipName);
 		}
 
 		// if we don't find one, but we have an embedded metadata object, check it
 		if (relationship == null && embedded != null) {
 			relationship = embedded.getRelationship(relationshipName);
 			// but, ensure it's not on the removed attribute list
 			if (relationship != null && removedRelationshipNames != null
 					&& removedRelationshipNames.contains(relationship.getName())) {
 				relationship = null;
 			}
 		}
 
 		return relationship;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public List<DataObjectRelationship> getRelationshipsInvolvingAttribute(String attributeName) {
 		// somewhat complex, since it returns a list of all possible relationships
 		if (StringUtils.isBlank(attributeName)) {
 			return null;
 		}
 
 		Map<Object, DataObjectRelationship> relationships = new HashMap<Object, DataObjectRelationship>();
 		// Look locally
 		if (attributeToRelationshipMap != null && attributeToRelationshipMap.containsKey(attributeName)) {
 			for (DataObjectRelationship rel : attributeToRelationshipMap.get(attributeName)) {
 				Object mergeKey = rel.getName();
 
 				if (rel instanceof MetadataCommonInternal) {
 					mergeKey = ((MetadataCommonInternal) rel).getUniqueKeyForMerging();
 				}
 
 				relationships.put(mergeKey, rel);
 			}
 		}
 
 		// now, if we have an embedded object, look for matching ones, but exclude if the relationship is the same
 		// as that means it was overridden by this bean
 		if (embedded != null) {
 			for (DataObjectRelationship rel : embedded.getRelationshipsInvolvingAttribute(attributeName)) {
 				Object mergeKey = rel.getName();
 
 				if (rel instanceof MetadataCommonInternal) {
 					mergeKey = ((MetadataCommonInternal) rel).getUniqueKeyForMerging();
 				}
 
 				if (!relationships.containsKey(mergeKey)) {
 					relationships.put(mergeKey, rel);
 				}
 			}
 		}
 
 		return new ArrayList<DataObjectRelationship>(relationships.values());
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public DataObjectRelationship getRelationshipByLastAttributeInRelationship(String attributeName) {
 		// this returns a single record, so we can just use the first matching one we find
 		if (StringUtils.isBlank(attributeName)) {
 			return null;
 		}
 
 		DataObjectRelationship relationship = null;
 
 		// Look locally
 		if (lastAttributeToRelationshipMap != null) {
 			relationship = lastAttributeToRelationshipMap.get(attributeName);
 		}
 
 		// if nothing found local, recurse into the embedded provider
 		if (relationship == null && embedded != null) {
 			relationship = embedded.getRelationshipByLastAttributeInRelationship(attributeName);
 		}
 
 		return relationship;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public DataObjectMetadataInternal getEmbedded() {
 		return embedded;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public void setEmbedded(DataObjectMetadataInternal embedded) {
 		this.embedded = embedded;
 		setEmbeddedCommonMetadata(embedded);
 	}
 
     /**
     * Gets the metadata source.
     *
     * <p>
     * Helper property to allow identification of the source of metadata. Value is transient, so it will not survive
     * serialization.
     * </p>
     *
     * @return metadata source
     */
 	public String getProviderName() {
 		return providerName;
 	}
 
     /**
     * Sets provider name.
     *
     * @param providerName name of provider
     */
 	public void setProviderName(String providerName) {
 		this.providerName = providerName;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public String toString() {
 		StringBuilder builder = new StringBuilder();
 		builder.append("DataObjectMetadata [");
 		builder.append("type=").append(getType()).append(", ");
 		builder.append("typeLabel=").append(label).append(", ");
 		builder.append("backingObjectName=").append(backingObjectName);
 		if (attributes != null && !attributes.isEmpty()) {
 			builder.append(", ").append("attributes=").append(attributes);
 		}
 		if (primaryKeyAttributeNames != null && !primaryKeyAttributeNames.isEmpty()) {
 			builder.append(", ").append("primaryKeyAttributeNames=").append(primaryKeyAttributeNames);
 		}
 		if (getPrimaryDisplayAttributeName() != null) {
 			builder.append(", ").append("primaryDisplayAttributeName=").append(getPrimaryDisplayAttributeName());
 		}
 		if (businessKeyAttributeNames != null && !businessKeyAttributeNames.isEmpty()) {
 			builder.append(", ").append("businessKeyAttributeNames=").append(businessKeyAttributeNames);
 		}
 		if (collections != null && !collections.isEmpty()) {
 			builder.append(", ").append("collections=").append(collections);
 		}
 		if (relationships != null && !relationships.isEmpty()) {
 			builder.append(", ").append("relationships=").append(relationships);
 		}
 		if (providerName != null) {
 			builder.append(", ").append("providerName=").append(providerName);
 		}
 		if (embedded != null) {
 			builder.append(", ").append("mergeAction=").append(mergeAction);
 			builder.append(", ").append("embedded=").append(embedded);
 		}
 		builder.append("]");
 		return builder.toString();
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
 	public boolean isSupportsOptimisticLocking() {
 		if (supportsOptimisticLocking != null) {
 			return supportsOptimisticLocking;
 		}
 
 		if (embedded != null) {
 			return embedded.isSupportsOptimisticLocking();
 		}
 
 		return false;
 	}
 
     /**
     * Sets whether optimistic locking is supported.
     *
     * @param supportsOptimisticLocking whether optimistic locking is supported
     */
 	public void setSupportsOptimisticLocking(boolean supportsOptimisticLocking) {
 		this.supportsOptimisticLocking = supportsOptimisticLocking;
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
     @Beta
 	public boolean shouldAutoCreateUifViewOfType(UifAutoCreateViewType viewType) {
 		if (getAutoCreateUifViewTypes() == null) {
 			return false;
 		}
 
 		return getAutoCreateUifViewTypes().contains(viewType)
 				|| getAutoCreateUifViewTypes().contains(UifAutoCreateViewType.ALL);
 	}
 
     /**
     * {@inheritDoc}
     */
 	@Override
     @Beta
 	public Collection<UifAutoCreateViewType> getAutoCreateUifViewTypes() {
 		if (autoCreateUifViewTypes != null) {
 			return autoCreateUifViewTypes;
 		}
 
 		if (embedded != null) {
 			return embedded.getAutoCreateUifViewTypes();
 		}
 
 		return null;
 	}
 
     /**
     * BETA: Sets list of UIF view types that will be auto created.
     *
     * @param autoCreateUifViewTypes UIF view types
     */
     @Beta
 	public void setAutoCreateUifViewTypes(Collection<UifAutoCreateViewType> autoCreateUifViewTypes) {
 		this.autoCreateUifViewTypes = autoCreateUifViewTypes;
 	}
 
     /**
     * Gets sorted attribute list.
     *
     * @return ordered attribute list
     */
 	public List<String> getOrderedAttributeList() {
 		return orderedAttributeList;
 	}
 
     /**
     * Sets sorted attribute list.
     *
     * @param orderedAttributeList sorted attributes
     */
 	public void setOrderedAttributeList(List<String> orderedAttributeList) {
 		this.orderedAttributeList = orderedAttributeList;
 	}
 
 }