| /* |
| * 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 <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) 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 <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 })); |
| } |
| } |
