• Home
• tools.xor
• xor
• 2.3.2
• source code
• AbstractBO.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

tools.xor.AbstractBO Maven / Gradle / Ivy

/**
 * XOR, empowering Model Driven Architecture in J2EE applications
 *
 * Copyright (c) 2012, Dilip Dalton
 *
 * 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 tools.xor;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONObject;

import tools.xor.operation.DenormalizedQueryOperation;
import tools.xor.operation.QueryOperation;
import tools.xor.operation.ReadOperation;
import tools.xor.service.Shape;
import tools.xor.util.ClassUtil;
import tools.xor.util.Constants;
import tools.xor.util.Edge;
import tools.xor.util.ObjectCreator;
import tools.xor.util.State;
import tools.xor.util.graph.TypeGraph;
import tools.xor.view.QueryFragment;
import tools.xor.view.QueryTree;
import tools.xor.view.QueryTreeInvocation;

public abstract class AbstractBO implements BusinessObject {
	private static final Logger logger = LogManager.getLogger(new Exception().getStackTrace()[0].getClassName());
	private static final long serialVersionUID = 1L;
	
	public static final String CURRENT = ".";

	// SDO Path related constants
    // This delimiter is used when entity name for downcast properties need to be provided
	// since the entity name usually contains Settings.PATH_DELIMITER, we use this instead
	public static final String SDO_PATH_DELIMITER = "/";
	public static final String INDEX_FROM_0   = ".";
	public static final String INDEX_START    = "[";
	public static final String INDEX_END      = "]";	
	public static final String PATH_CONTAINER = "..";
	public static final String ATTR_DELIMITER = "=";	
	public static final String INSERT_OPERATOR = "+";  // insert at index for a set operation. Returns the element at index for a get operation.
	public static final String APPEND_OPERATOR = "<<"; // append at end of list for a set operation. Returns the last element in a GET operation.

	protected Object               instance;            // The object containing the actual data. This can be a JPA/Hibernate/Javabean object.
	protected Type                 type;                // Represents the type of the entity, that holds the properties that make up this entity
	protected Type                 propertyType;        // If the instance is an object of a subtype, then type will hold the actual subtype and propertyType will hold
														// the type of the property referencing this object
	protected boolean              persistent;          // This flag is set to true, if the object was created from the persistence store
	protected boolean              modified;            // This flag is set to true, if any fields or collections have been modified
	protected ObjectCreator        objectCreator;       // Cache to hold objects. Useful to set multiple references to an object and providing repeatable read capability. object.

	// TODO: Move to ObjectGraph
	protected DataObject      container;                // A reference to owning object of this entity in an aggregate
	protected Property        containmentProperty;      // Represents the property referenced from the owning entity to this entity
	protected boolean         visited;                  // Used to prevent loops when traversing the graph	
	
	// TODO: Move to ObjectCreator
	protected ObjectPersister objectPersister;          // Mechanism used to resolve dependencies and property order persistence related actions without causing data integrity conflicts.

	
	@Override
	public boolean isPersistent() {
		return this.persistent;
	}
	
	@Override
	public void setPersistent(boolean persistent) {
		this.persistent = persistent;
	}
	
	@Override
	public boolean isDependent() {
		return getContainmentProperty() != null && getContainmentProperty().isContainment();
	}

	@Override
	public Type getPropertyType() {
		return this.propertyType;
	}

	@Override
	public ObjectPersister getObjectPersister() {
		return objectPersister;
	}

	public AbstractBO(Type type, DataObject container, Property containmentProperty, ObjectCreator objectCreator) {
		this.type                = type;
		this.container           = container;
		this.containmentProperty = containmentProperty;
		this.propertyType = type;

		// Can be null - then the business object is light weight
		// as it will not "bloat" the object creator
		this.objectCreator       = objectCreator;
	}

	@Override
	public boolean isRoot() {
		return this == getRootObject();
	}

	@Override
	public boolean isVisited() {
		return visited;
	}

	@Override
	public void setVisited(boolean visited) {
		this.visited = visited;
	}
	
	/**
	 * This is also used in the External Business Object for performance reasons
	 * to walk only those paths that have been modified
	 */
	@Override
	public boolean isModified() {
		return modified;
	}

	@Override
	public void setModified(boolean modified) {
		this.modified = modified;
	}

	@Override
	public EntityKey getSurrogateKey () {
		return getSurrogateKey(null);
	}

	@Override
	public List getNaturalKey() {
		return getNaturalKey(null);
	}

	@Override
	public List getNaturalKey(String anchor) {
		return getObjectCreator().getTypeMapper().getNaturalKey(this, anchor);
	}

	@Override
	public EntityKey getSurrogateKey (String anchor) {
		return getObjectCreator().getTypeMapper().getSurrogateKey(getIdentifierValue(), getType(), anchor);
	}

	@Override
	public void removeEntity(BusinessObject entity, String anchor) {
		/*
		EntityKey entityKey = getObjectCreator().getTypeMapper().getEntityKey(
			entity.getIdentifierValue(),
			entity);
		getObjectCreator().removeByEntityKey(entityKey);
		*/

		EntityKey surrogateKey = getObjectCreator().getTypeMapper().getSurrogateKey(entity.getIdentifierValue(), entity.getType(), anchor);
		getObjectCreator().removeByEntityKey(surrogateKey);

		List naturalKeys = getObjectCreator().getTypeMapper().getNaturalKey(entity, anchor);
		for(EntityKey naturalKey: naturalKeys) {
			getObjectCreator().removeByEntityKey(naturalKey);
		}
	}

	/**
	 * Check if the existingEntity is a valid for the given naturalKey
	 * @param naturalKey derived from newEntity
	 * @param newEntity used to check the existence of an entity based on its natural keys
	 * @param existingEntity if any already registered
	 * @param anchor state tree path that determines the shape of the entity
	 * @return true if an existingEntity is found with the same natural key
	 */
	private boolean isValidEntity(EntityKey naturalKey, BusinessObject newEntity, BusinessObject existingEntity, String anchor) {
		boolean result = true;

		if (existingEntity != newEntity) {
			// The natural field values could have changed during the creation/clone/update
			// operations for the existingEntity. So check its Natural Key.
			List existingNK = existingEntity.getNaturalKey();
			if (existingNK == null || !existingNK.contains(naturalKey)) {
				// Remove the incorrect natural key mapping to the existing BO
				getObjectCreator().removeByEntityKey(naturalKey);

				// Update the existing BO with the correct natural key mapping
				if (existingNK != null && existingEntity != null) {
					getObjectCreator().addByNaturalKey(existingEntity, anchor);
				}

				result = false;
			}
		}

		return result;
	}

	@Override
	public BusinessObject getEntity (BusinessObject entity, String anchor)
	{
		BusinessObject existingEntity = null;

		// First retrieve by Natural Key
		List naturalKeys = entity.getNaturalKey(anchor);
		for (EntityKey naturalKey: naturalKeys) {
			existingEntity = getObjectCreator().getByEntityKey(naturalKey, entity.getType());
			if(existingEntity != null && isValidEntity(naturalKey, entity, existingEntity, anchor)) {
				break;
			}
		}

		// try using the surrogate key
		if (existingEntity == null) {
			EntityKey entityKey = entity.getSurrogateKey(anchor);
			if (entityKey != null) {
				existingEntity = getObjectCreator().getByEntityKey(entityKey, entity.getType());
				if(existingEntity != null) {
					EntityKey existingSK = existingEntity.getSurrogateKey(anchor);

					// If for some reason the id has changed
					if (existingSK == null || !existingSK.equals(entityKey)) {
						getObjectCreator().addBySurrogateKey(existingEntity, anchor);

						// The existing BO is mapped to the incorrect surrogate key
						existingEntity = null;
					}

					// make sure it is found by its natural key
					getObjectCreator().addByNaturalKey(existingEntity, anchor);
				}
			}
		}

		return existingEntity;
	}
	
	@Override
	public BusinessObject getBySurrogateKey(Object id, Type type) {
		return getObjectCreator().getByEntityKey(new SurrogateEntityKey(id, AbstractTypeMapper.getSurrogateKeyTypeName(type)), type);
	}

	@Override
	public BusinessObject getBySurrogateKey(Object id, Type type, String path) {
		return getObjectCreator().getByEntityKey(new SurrogateEntityKey(id, AbstractTypeMapper.getSurrogateKeyTypeName(type), path), type);
	}

	@Override
	public BusinessObject getByNaturalKey(Map naturalKeyValues, Type type) {
		return getObjectCreator().getByEntityKey(
			new NaturalEntityKey(
				naturalKeyValues,
				AbstractTypeMapper.getNaturalKeyTypeName(type)), type);
	}

	@Override
	public BusinessObject getByNaturalKey(Map naturalKeyValues, Type type, String path) {
		return getObjectCreator().getByEntityKey(
			new NaturalEntityKey(
				naturalKeyValues,
				AbstractTypeMapper.getNaturalKeyTypeName(type),
				path), type);
	}

	private Map getKeyValue(Set keys) {
		Map keyValues = new HashMap();
		for(String key: keys) {
			keyValues.put(key, get(key));
		}
		return keyValues;
	}	

	@Override
	/**
	 * Invoked on the Collection Element data object
	 */
	public Object getCollectionElementKey(Property property) {

		Set collectionKey = ((ExtendedProperty)property).getCollectionKey();
		if( collectionKey != null ) {
			return getKeyValue(collectionKey);
		} else if ( ((ExtendedProperty)property).getPositionProperty() != null) {
			return this.get(((ExtendedProperty)property).getPositionProperty());
		} else { // fallback to id
			/* NOTE: the passed in property may be of a subtype or a sibling type of the
		     *  actual collection element object, so we cannot use the property type's identifier property
		     */
			if(! (getType() instanceof EntityType)) {
				throw new RuntimeException("Unable to obtain a key for the collection element, please define a collection key for: " + getType().getName());
			}
			Property identifier = ((EntityType)getType()).getIdentifierProperty();
			return (this.get(identifier) == null) ? null : this.get(identifier).toString();
		}
	}

	@Override
	public String getInstanceClassName ()
	{
		if(instance == null) {
			return null;
		}

		if (instance.getClass() != JSONObject.class || !((JSONObject)instance).has(Constants.XOR.TYPE)) {
			if (instance.getClass() != JSONObject.class) {
				return ClassUtil.getUnEnhanced(instance.getClass()).getName();
			}
			else {
				// Cannot get the specific type, so return the interface type
				return getType().getName();
			}
		}
		else {
			return ((JSONObject)instance).getString(Constants.XOR.TYPE);
		}
	}
	
	@Override
	public String getOpenProperty(String propertyName) {
		if(instance instanceof JSONObject) {
			if(((JSONObject)instance).has(propertyName)) {
				return ((JSONObject)instance).getString(propertyName);
			}
		}
		
		return null;
	}

	@Override
	public Object getInstance() {
		return instance;
	}
	
	@Override
	public Object getNormalizedInstance(Settings settings) {
		return objectCreator.getCreationStrategy().getNormalizedInstance(this, settings);
	}	

	@Override
	public void setInstance(Object instance) {
		if(this.instance == instance)
			return;
		
		if(instance != null && this.getContainmentProperty() != null) {
			ExtendedProperty property = (ExtendedProperty) this.getContainmentProperty();
			
			// We skip check for dynamic types
			if(!property.getType().isOpen() && !objectCreator.getTypeMapper().isOpen(instance.getClass())) {
				if( (property.isSet() && !Set.class.isAssignableFrom(instance.getClass())) ||
						(property.isList() && !List.class.isAssignableFrom(instance.getClass())) ||
						(property.isMap() && !Map.class.isAssignableFrom(instance.getClass())) ||
						( !property.isSet() && !property.isList() && !property.isMap() && !type.getInstanceClass().isAssignableFrom(instance.getClass())) ) {
					logger.error("Instance class and type conflict: Instance class: " 
							+ instance.getClass().getName() + ", type: " 
							+ getType().getName() + ", containment property type: " 
							+ this.getContainmentProperty().getType().getName() + ", containment property class: "
							+ this.getContainmentProperty().getType().getInstanceClass().getName() + ", containment property name: "
							+ this.getContainmentProperty().getName());

					throw new IllegalArgumentException("The DataObject instance class " + instance.getClass().getName() 
							+ " is not compatible with its type " + property.getType().getName()
							+ " property: " + property.getName()
							+ " type class: " + property.getType().getInstanceClass().getName()
							+ " property class: " + property.getClass().getName()
							+ " type class: " + property.getType().getClass().getName());
				}
			}
		}

		if(BusinessObject.class.isAssignableFrom(instance.getClass()))
			throw new RuntimeException("Cannot assign a data object as an instance");
		
		Object oldInstance = this.instance;
		this.instance = instance;

		if(objectCreator != null) {
			objectCreator.updateInstance(this, oldInstance);
		}
	}

	private boolean isIndexOperation(String indexStr) {
		if(indexStr.trim().endsWith(INSERT_OPERATOR) || indexStr.trim().equals(APPEND_OPERATOR))
			return true;

		return false;
	}

	private Object getIndexObject(String indexStr, String propertyName) {
		if(indexStr.trim().endsWith(INSERT_OPERATOR)) {
			int index = Integer.parseInt(indexStr.substring(0, indexStr.indexOf(INSERT_OPERATOR)).trim() );
			return ((List)get(getType().getProperty(propertyName))).get(index);
		} else if(indexStr.trim().equals(APPEND_OPERATOR)) {
			List listObj = (List)get(getType().getProperty(propertyName));
			return listObj.get(listObj.size()-1);
		}

		return null;
	}

	@SuppressWarnings("unchecked")
	private void setIndexObject(String indexStr, String propertyName, Object value) {
		List