/*
* Copyright 2004-2009 the original author or authors.
*
* 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 org.compass.core.converter.mapping.osem;
import org.compass.core.Property;
import org.compass.core.Resource;
import org.compass.core.converter.ConversionException;
import org.compass.core.converter.Converter;
import org.compass.core.converter.mapping.CollectionResourceWrapper;
import org.compass.core.mapping.Mapping;
import org.compass.core.mapping.osem.ClassMapping;
import org.compass.core.mapping.osem.RefAliasObjectMapping;
import org.compass.core.marshall.MarshallingContext;
import org.compass.core.marshall.MarshallingEnvironment;
import org.compass.core.util.ClassUtils;
import org.compass.core.util.StringUtils;
/**
* @author kimchy
*/
public abstract class AbstractRefAliasMappingConverter implements Converter {
public boolean marshall(Resource resource, Object root, Mapping mapping, MarshallingContext context) throws ConversionException {
RefAliasObjectMapping hasRefAliasMapping = (RefAliasObjectMapping) mapping;
ClassMapping[] classMappings = hasRefAliasMapping.getRefClassMappings();
ClassMapping classMapping;
if (root == null || classMappings.length == 1) {
classMapping = classMappings[0];
} else {
classMapping = extractClassMapping(context, root.getClass(), resource, hasRefAliasMapping);
}
Object current = context.getAttribute(MarshallingEnvironment.ATTRIBUTE_CURRENT);
context.setAttribute(MarshallingEnvironment.ATTRIBUTE_PARENT, current);
return doMarshall(resource, root, hasRefAliasMapping, classMapping, context);
}
protected abstract boolean doMarshall(Resource resource, Object root, RefAliasObjectMapping hasRefAliasMapping,
ClassMapping refMapping, MarshallingContext context) throws ConversionException;
public Object unmarshall(Resource resource, Mapping mapping, MarshallingContext context) throws ConversionException {
RefAliasObjectMapping hasRefAliasMapping = (RefAliasObjectMapping) mapping;
ClassMapping[] classMappings = hasRefAliasMapping.getRefClassMappings();
ClassMapping classMapping = null;
if (classMappings.length == 1) {
classMapping = classMappings[0];
} else {
// this for loop is really not required, since all of them
// will have the same class path
for (int i = 0; i < classMappings.length; i++) {
if (classMappings[i].isPoly()) {
String classPath = classMappings[i].getClassPath().getPath();
Property pClassName = resource.getProperty(classPath);
// HACK HACK HACK
// since ClassMappingConverter will also read the path, we need
// to take special care when working with a collection resource wrapper
// and rollback the fact that we read the path
if ((resource instanceof CollectionResourceWrapper) && rollbackClassNameOnPoly()) {
((CollectionResourceWrapper) resource).rollbackGetProperty(classPath);
}
if (pClassName != null && pClassName.getStringValue() != null) {
// we stored the class, use it to find the "nearset" class mappings
Class clazz;
try {
clazz = ClassUtils.forName(pClassName.getStringValue(), context.getSession().getCompass().getSettings().getClassLoader());
} catch (ClassNotFoundException e) {
throw new ConversionException("Failed to create class [" + pClassName.getStringValue() + "]", e);
}
classMapping = extractClassMapping(context, clazz, resource, hasRefAliasMapping);
break;
}
}
}
if (classMapping == null) {
// we did not find anything stored in the index, it must have poly-class set
for (int i = 0; i < classMappings.length; i++) {
if (classMappings[i].getPolyClass() != null) {
classMapping = classMappings[i];
break;
}
}
}
if (classMapping == null) {
// just try and use the first one and hope it is what we need
classMapping = classMappings[0];
}
}
Object current = context.getAttribute(MarshallingEnvironment.ATTRIBUTE_CURRENT);
context.setAttribute(MarshallingEnvironment.ATTRIBUTE_PARENT, current);
return doUnmarshall(resource, hasRefAliasMapping, classMapping, context);
}
/**
* Extracts the given class mappings based on the provided class. Will find the "nearest"
* class mapping that match the class, then will check if it was set in the ref-alias,
* and return the class mapping set against the ref-alias.
*/
private ClassMapping extractClassMapping(MarshallingContext context, Class clazz, Resource resource,
RefAliasObjectMapping hasRefAliasMapping) throws ConversionException {
ClassMapping classMapping;
ClassMapping origClassMapping = (ClassMapping) context.getCompassMapping().getMappingByClass(clazz);
if (origClassMapping == null) {
throw new ConversionException("No class mapping found when marshalling root alias ["
+ resource.getAlias() + "] and class [" + clazz + "]");
}
classMapping = hasRefAliasMapping.getRefClassMapping(origClassMapping.getAlias());
if (classMapping == null) {
throw new ConversionException("Mapping for root alias [" + resource.getAlias() +
"] with one of its mappings with multiple ref-alias ["
+ StringUtils.arrayToCommaDelimitedString(hasRefAliasMapping.getRefAliases())
+ "] did not match [" + origClassMapping.getAlias() + "]");
}
return classMapping;
}
protected abstract Object doUnmarshall(Resource resource, RefAliasObjectMapping hasRefAliasMapping,
ClassMapping refMapping, MarshallingContext context) throws ConversionException;
protected boolean rollbackClassNameOnPoly() {
return true;
}
}