/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* dmccann - September 15/2009 - 1.2 - Initial implementation
******************************************************************************/
package org.eclipse.persistence.sdo;
import org.eclipse.persistence.internal.localization.ExceptionLocalization;
import org.eclipse.persistence.oxm.XMLContext;
import org.eclipse.persistence.sdo.helper.SDOCopyHelper;
import org.eclipse.persistence.sdo.helper.SDODataFactory;
import org.eclipse.persistence.sdo.helper.SDODataHelper;
import org.eclipse.persistence.sdo.helper.SDOEqualityHelper;
import org.eclipse.persistence.sdo.helper.SDOHelperContext;
import org.eclipse.persistence.sdo.helper.SDOTypeHelper;
import org.eclipse.persistence.sdo.helper.SDOXMLHelper;
import org.eclipse.persistence.sdo.helper.SDOXSDHelper;
import org.eclipse.persistence.sdo.types.SDOChangeSummaryType;
import org.eclipse.persistence.sdo.types.SDODataObjectType;
import org.eclipse.persistence.sdo.types.SDODataType;
import org.eclipse.persistence.sdo.types.SDOObjectType;
import org.eclipse.persistence.sdo.types.SDOOpenSequencedType;
import org.eclipse.persistence.sdo.types.SDOPropertyType;
import org.eclipse.persistence.sdo.types.SDOTypeType;
import org.eclipse.persistence.sdo.types.SDOWrapperType;
import org.eclipse.persistence.sdo.types.SDOXMLHelperLoadOptionsType;
import commonj.sdo.ChangeSummary;
import commonj.sdo.DataObject;
import commonj.sdo.Property;
import commonj.sdo.Sequence;
import commonj.sdo.Type;
import commonj.sdo.helper.CopyHelper;
import commonj.sdo.helper.DataFactory;
import commonj.sdo.helper.DataHelper;
import commonj.sdo.helper.EqualityHelper;
import commonj.sdo.helper.HelperContext;
import commonj.sdo.helper.TypeHelper;
import commonj.sdo.helper.XMLHelper;
import commonj.sdo.helper.XSDHelper;
import commonj.sdo.impl.HelperProvider;
/**
* This class provides a mechanism to obtain the EclipseLink implementation of various SDO runtime
* classes based on a given SDO class/interface. This is useful for accessing extended EclipseLink
* features. Using this helper class will alleviate the need for consumers of EclipseLink SDO to
* perform casts where their code makes use of the standard SDO API. In addition, a given SDO
* class/interface can be unwrapped based on a user-specified class. This will allow access - in
* certain cases - to a given SDO implementation class' underlying class(es). For example, an
* XMLHelper could be unwrapped resulting in an EclipseLink SDOXMLHelper or its underlying
* XMLContext.
*/
public class SDOHelper {
/**
* Return the EclipseLink implementation of Type. The given Type is assumed to be an instance of
* {@link org.eclipse.persistence.sdo.SDOType}. If not, an exception will be thrown.
*
* @param type
* @return
* @throws IllegalArgumentException
*/
public static SDOType getType(Type type) throws IllegalArgumentException {
try {
return (SDOType) type;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_type", new Object[] { type.getClass() }));
}
}
/**
* Return the EclipseLink implementation of Property. The given Property is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.SDOProperty}. If not, an exception will be
* thrown.
*
* @param property
* @return
* @throws IllegalArgumentException
*/
public static SDOProperty getProperty(Property property) throws IllegalArgumentException {
try {
return (SDOProperty) property;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_property", new Object[] { property.getClass() }));
}
}
/**
* Return the EclipseLink implementation of DataObject. The given DataObject is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.SDODataObject}. If not, an exception will be
* thrown.
*
* @param dataObject
* @return
* @throws IllegalArgumentException
*/
public static SDODataObject getDataObject(DataObject dataObject) throws IllegalArgumentException {
try {
return (SDODataObject) dataObject;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_dataobject", new Object[] { dataObject.getClass() }));
}
}
/**
* Return the EclipseLink implementation of ChangeSummary. The given ChangeSummary is assumed to
* be an instance of {@link org.eclipse.persistence.sdo.SDOChangeSummary}. If not, an exception
* will be thrown.
*
* @param changeSummary
* @return
* @throws IllegalArgumentException
*/
public static SDOChangeSummary getChangeSummary(ChangeSummary changeSummary) throws IllegalArgumentException {
try {
return (SDOChangeSummary) changeSummary;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_changesummary", new Object[] { changeSummary.getClass() }));
}
}
/**
* Return the EclipseLink implementation of Sequence. The given Sequence is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.SDOSequence}. If not, an exception will be
* thrown.
*
* @param sequence
* @return
* @throws IllegalArgumentException
*/
public static SDOSequence getSequence(Sequence sequence) throws IllegalArgumentException {
try {
return (SDOSequence) sequence;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_sequence", new Object[] { sequence.getClass() }));
}
}
/**
* Return the EclipseLink implementation of HelperContext. If the given HelperContext
* is an instance of the DefaultContext, an SDOHelperContext will be obtained via
* SDOHelperContext.getHelperContext(). Otherwise, the given HelperContext is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDOHelperContext}. If not, an exception
* will be thrown.
* @param helperContext
* @return
* @throws IllegalArgumentException
*/
public static SDOHelperContext getHelperContext(HelperContext helperContext) throws IllegalArgumentException {
if (helperContext == HelperProvider.getDefaultContext()) {
return (SDOHelperContext) SDOHelperContext.getHelperContext();
}
try {
return (SDOHelperContext) helperContext;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_helpercontext", new Object[] { helperContext.getClass() }));
}
}
/**
* Return the EclipseLink implementation of CopyHelper. The given CopyHelper is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDOCopyHelper}. If not, an exception
* will be thrown.
*
* @param copyHelper
* @return
* @throws IllegalArgumentException
*/
public static SDOCopyHelper getCopyHelper(CopyHelper copyHelper) throws IllegalArgumentException {
try {
return (SDOCopyHelper) copyHelper;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_copyhelper", new Object[] { copyHelper.getClass() }));
}
}
/**
* Return the EclipseLink implementation of DataFactory. The given DataFactory is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDODataFactory}. If not, an exception
* will be thrown.
*
* @param dataFactory
* @return
* @throws IllegalArgumentException
*/
public static SDODataFactory getDataFactory(DataFactory dataFactory) throws IllegalArgumentException {
try {
return (SDODataFactory) dataFactory;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_datafactory", new Object[] { dataFactory.getClass() }));
}
}
/**
* Return the EclipseLink implementation of DataHelper. The given DataHelper is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDODataHelper}. If not, an exception
* will be thrown.
*
* @param dataHelper
* @return
* @throws IllegalArgumentException
*/
public static SDODataHelper getDataHelper(DataHelper dataHelper) throws IllegalArgumentException {
try {
return (SDODataHelper) dataHelper;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_datahelper", new Object[] { dataHelper.getClass() }));
}
}
/**
* Return the EclipseLink implementation of EqualityHelper. The given EqualityHelper is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDOEqualityHelper}. If not, an exception
* will be thrown.
*
* @param equalityHelper
* @return
* @throws IllegalArgumentException
*/
public static SDOEqualityHelper getEqualityHelper(EqualityHelper equalityHelper) throws IllegalArgumentException {
try {
return (SDOEqualityHelper) equalityHelper;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_equalityhelper", new Object[] { equalityHelper.getClass() }));
}
}
/**
* Return the EclipseLink implementation of TypeHelper. The given TypeHelper is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDOTypeHelper}. If not, an exception
* will be thrown.
*
* @param typeHelper
* @return
* @throws IllegalArgumentException
*/
public static SDOTypeHelper getTypeHelper(TypeHelper typeHelper) throws IllegalArgumentException {
try {
return (SDOTypeHelper) typeHelper;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_typehelper", new Object[] { typeHelper.getClass() }));
}
}
/**
* Return the EclipseLink implementation of XMLHelper. The given XMLHelper is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDOXMLHelper}. If not, an exception
* will be thrown.
*
* @param xmlHelper
* @return
* @throws IllegalArgumentException
*/
public static SDOXMLHelper getXMLHelper(XMLHelper xmlHelper) throws IllegalArgumentException {
try {
return (SDOXMLHelper) xmlHelper;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_xmlhelper", new Object[] { xmlHelper.getClass() }));
}
}
/**
* Return the EclipseLink implementation of XSDHelper. The given XSDHelper is assumed to be an
* instance of {@link org.eclipse.persistence.sdo.helper.SDOXSDHelper}. If not, an exception
* will be thrown.
*
* @param xsdHelper
* @return
* @throws IllegalArgumentException
*/
public static SDOXSDHelper getXSDHelper(XSDHelper xsdHelper) throws IllegalArgumentException {
try {
return (SDOXSDHelper) xsdHelper;
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_xsdhelper", new Object[] { xsdHelper.getClass() }));
}
}
/**
* Unwraps a given Type resulting in an EclipseLink SDOType. Assumes that the
* given Type is an instance of EclipseLink SDOType, and clazz is one of:
* org.eclipse.persistence.sdo.SDOType,
* org.eclipse.persistence.sdo.type.SDOTypeType,
* org.eclipse.persistence.sdo.type.SDOPropertyType,
* org.eclipse.persistence.sdo.type.SDOChangeSummaryType,
* org.eclipse.persistence.sdo.type.SDODataObjectType,
* org.eclipse.persistence.sdo.type.SDODataType,
* org.eclipse.persistence.sdo.type.SDOOpenSequencedType,
* org.eclipse.persistence.sdo.type.SDOObjectType,
* org.eclipse.persistence.sdo.type.SDOWrapperType,
* org.eclipse.persistence.sdo.type.SDOXMLHelperLoadOptionsType
*
* @param <T>
* @param type
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(Type type, Class<T> clazz) throws IllegalArgumentException {
if (clazz == SDOType.class) {
return (T) getType(type);
}
try {
if (clazz == SDOTypeType.class) {
return (T) ((SDOTypeType) type);
}
if (clazz == SDOPropertyType.class) {
return (T) ((SDOPropertyType) type);
}
if (clazz == SDOChangeSummaryType.class) {
return (T) ((SDOChangeSummaryType) type);
}
if (clazz == SDODataObjectType.class) {
return (T) ((SDODataObjectType) type);
}
if (clazz == SDODataType.class) {
return (T) ((SDODataType) type);
}
if (clazz == SDOOpenSequencedType.class) {
return (T) ((SDOOpenSequencedType) type);
}
if (clazz == SDOWrapperType.class) {
return (T) ((SDOWrapperType) type);
}
if (clazz == SDOXMLHelperLoadOptionsType.class) {
return (T) ((SDOXMLHelperLoadOptionsType) type);
}
if (clazz == SDOObjectType.class) {
return (T) ((SDOObjectType) type);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_type", new Object[] { clazz }));
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_type", new Object[] { type.getClass() }));
}
}
/**
* Unwraps a given Property resulting in an EclipseLink SDOProperty. Assumes that the
* given Property is an instance of EclipseLink SDOProperty, and clazz is
* org.eclipse.persistence.sdo.SDOProperty.
*
* @param <T>
* @param property
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(Property property, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.SDOProperty.class) {
return (T) getProperty(property);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_property", new Object[] { clazz }));
}
/**
* Unwraps a given DataObject resulting in an EclipseLink SDODataObject. Assumes that the
* given DataObject is an instance of EclipseLink SDODataObject, and clazz is
* org.eclipse.persistence.sdo.SDODataObject.
*
* @param <T>
* @param dataObject
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(DataObject dataObject, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.SDODataObject.class) {
return (T) getDataObject(dataObject);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_dataobject", new Object[] { clazz }));
}
/**
* Unwraps a given ChangeSummary resulting in an EclipseLink SDOChangeSummary. Assumes that the
* given ChangeSummary is an instance of EclipseLink SDOChangeSummary, and clazz is
* org.eclipse.persistence.sdo.SDOChangeSummary.
*
* @param <T>
* @param changeSummary
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(ChangeSummary changeSummary, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.SDOChangeSummary.class) {
return (T) getChangeSummary(changeSummary);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_changesummary", new Object[] { clazz }));
}
/**
* Unwraps a given Sequence resulting in an EclipseLink SDOSequence. Assumes that the
* given Sequence is an instance of EclipseLink SDOSequence, and clazz is
* org.eclipse.persistence.sdo.SDOSequence.
*
* @param <T>
* @param sequence
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(Sequence sequence, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.SDOSequence.class) {
return (T) getSequence(sequence);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_sequence", new Object[] { clazz }));
}
/**
* Unwraps a given HelperContext resulting in an EclipseLink SDOHelperContext. Assumes that the
* given HelperContext is an instance of EclipseLink SDOHelperContext, and clazz is
* org.eclipse.persistence.sdo.helper.SDOHelperContext.
*
* @param <T>
* @param helperContext
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(HelperContext helperContext, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDOHelperContext.class) {
return (T) getHelperContext(helperContext);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_helpercontext", new Object[] { clazz }));
}
/**
* Unwraps a given CopyHelper resulting in an EclipseLink SDOCopyHelper. Assumes that the
* given CopyHelper is an instance of EclipseLink SDOCopyHelper, and clazz is
* org.eclipse.persistence.sdo.helper.SDOCopyHelper.
*
* @param <T>
* @param copyHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(CopyHelper copyHelper, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDOCopyHelper.class) {
return (T) getCopyHelper(copyHelper);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_copyhelper", new Object[] { clazz }));
}
/**
* Unwraps a given DataFactory resulting in an EclipseLink SDODataFactory. Assumes that the
* given DataFactory is an instance of EclipseLink SDODataFactory, and clazz is
* org.eclipse.persistence.sdo.helper.SDODataFactory.
*
* @param <T>
* @param dataFactory
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(DataFactory dataFactory, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDODataFactory.class) {
return (T) getDataFactory(dataFactory);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_datafactory", new Object[] { clazz }));
}
/**
* Unwraps a given DataHelper resulting in an EclipseLink SDODataHelper. Assumes that the
* given DataHelper is an instance of EclipseLink SDODataHelper, and clazz is
* org.eclipse.persistence.sdo.helper.SDODataHelper.
*
* @param <T>
* @param dataHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(DataHelper dataHelper, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDODataHelper.class) {
return (T) getDataHelper(dataHelper);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_datahelper", new Object[] { clazz }));
}
/**
* Unwraps a given EqualityHelper resulting in an EclipseLink SDOEqualityHelper. Assumes that the
* given EqualityHelper is an instance of EclipseLink SDOEqualityHelper, and clazz is
* org.eclipse.persistence.sdo.helper.SDOEqualityHelper.
*
* @param <T>
* @param equalityHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(EqualityHelper equalityHelper, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDOEqualityHelper.class) {
return (T) getEqualityHelper(equalityHelper);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_equalityhelper", new Object[] { clazz }));
}
/**
* Unwraps a given TypeHelper resulting in an EclipseLink SDOTypeHelper. Assumes that the
* given TypeHelper is an instance of EclipseLink SDOTypeHelper, and clazz is
* org.eclipse.persistence.sdo.helper.SDOTypeHelper.
*
* @param <T>
* @param typeHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(TypeHelper typeHelper, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDOTypeHelper.class) {
return (T) getTypeHelper(typeHelper);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_typehelper", new Object[] { clazz }));
}
/**
* Unwraps a given XMLHelper resulting in an EclipseLink SDOXMLHelper or an EclipseLink
* XMLContext depending on clazz. Assumes that the given XMLHelper is an instance of
* EclipseLink SDOXMLHelper, and clazz is one of
* org.eclipse.persistence.sdo.helper.SDOXMLHelper, or
* org.eclipse.persistence.oxm.XMLContext. If not, an exception will be thrown.
*
* @param <T>
* @param xmlHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(XMLHelper xmlHelper, Class<T> clazz) throws IllegalArgumentException {
try {
org.eclipse.persistence.sdo.helper.SDOXMLHelper xmlHelperImpl = (org.eclipse.persistence.sdo.helper.SDOXMLHelper) xmlHelper;
if (clazz == org.eclipse.persistence.sdo.helper.SDOXMLHelper.class) {
return (T) xmlHelperImpl;
}
if (clazz == XMLContext.class) {
return (T) xmlHelperImpl.getXmlContext();
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_xmlhelper", new Object[] { clazz }));
} catch (ClassCastException e) {
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_xmlhelper", new Object[] { xmlHelper.getClass() }));
}
}
/**
* Unwraps a given XSDHelper resulting in an EclipseLink SDOXSDHelper. Assumes that the
* given XSDHelper is an instance of EclipseLink SDOXSDHelper, and clazz is
* org.eclipse.persistence.sdo.helper.SDOXSDHelper.
*
* @param <T>
* @param xsdHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
public static <T> T unwrap(XSDHelper xsdHelper, Class<T> clazz) throws IllegalArgumentException {
if (clazz == org.eclipse.persistence.sdo.helper.SDOXSDHelper.class) {
return (T) getXSDHelper(xsdHelper);
}
throw new IllegalArgumentException(ExceptionLocalization
.buildMessage("sdo_helper_invalid_target_for_xsdhelper", new Object[] { clazz }));
}
}