org.eclipse.persistence.sdo.SDOHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of eclipselink Show documentation
Show all versions of eclipselink Show documentation
EclipseLink build based upon Git transaction f2b9fc5
/*
* Copyright (c) 1998, 2021 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 v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0,
* or the Eclipse Distribution License v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
// 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 {
private SDOHelper() {
//no instance please
}
/**
* 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
* @param type
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(Type type, Class clazz) throws IllegalArgumentException {
if (clazz == SDOType.class) {
return (T) getType(type);
}
try {
if (clazz == SDOTypeType.class) {
return (T) type;
}
if (clazz == SDOPropertyType.class) {
return (T) type;
}
if (clazz == SDOChangeSummaryType.class) {
return (T) type;
}
if (clazz == SDODataObjectType.class) {
return (T) type;
}
if (clazz == SDODataType.class) {
return (T) type;
}
if (clazz == SDOOpenSequencedType.class) {
return (T) type;
}
if (clazz == SDOWrapperType.class) {
return (T) type;
}
if (clazz == SDOXMLHelperLoadOptionsType.class) {
return (T) type;
}
if (clazz == SDOObjectType.class) {
return (T) 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
* @param property
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(Property property, Class 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
* @param dataObject
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(DataObject dataObject, Class 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
* @param changeSummary
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(ChangeSummary changeSummary, Class 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
* @param sequence
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(Sequence sequence, Class 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
* @param helperContext
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(HelperContext helperContext, Class 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
* @param copyHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(CopyHelper copyHelper, Class 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
* @param dataFactory
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(DataFactory dataFactory, Class 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
* @param dataHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(DataHelper dataHelper, Class 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
* @param equalityHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(EqualityHelper equalityHelper, Class 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
* @param typeHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(TypeHelper typeHelper, Class 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
* @param xmlHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(XMLHelper xmlHelper, Class 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
* @param xsdHelper
* @param clazz
* @return
* @throws IllegalArgumentException
*/
@SuppressWarnings({"unchecked"})
public static T unwrap(XSDHelper xsdHelper, Class 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 }));
}
}