private Object handleArrayData(Class returnType, Object value) { if (value == null) { return null; } Object[] data = (Object[]) value; Class componentType = returnType.getComponentType(); Object[] convertedArray = (Object[]) Array.newInstance(componentType, data.length); for (int i = 0; i < data.length; i++) { convertedArray[i] = conversionMgr.convertObject(data[i], componentType); } return convertedArray; }
/** * Lookup the DynamicConversionManager for the given session. If the * existing ConversionManager is not an instance of DynamicConversionManager * then create a new one and replace the existing one. * * @param session * @return */ public static DynamicClassLoader lookup(Session session) { ConversionManager cm = null; if (session == null) { cm = ConversionManager.getDefaultManager(); } else { cm = session.getPlatform().getConversionManager(); } if (cm.getLoader() instanceof DynamicClassLoader) { return (DynamicClassLoader) cm.getLoader(); } DynamicClassLoader dcl = new DynamicClassLoader(cm.getLoader()); cm.setLoader(dcl); if (session == null) { ConversionManager.setDefaultLoader(dcl); } return dcl; }
/** * A singleton conversion manager is used to handle generic conversions. * This should not be used for conversion under the session context, these must go through the platform. * This allows for the singleton to be customized through setting the default to a user defined subclass. */ public static ConversionManager getDefaultManager() { if (defaultManager == null) { setDefaultManager(new ConversionManager()); defaultManager.setShouldUseClassLoaderFromCurrentThread(true); } return defaultManager; }
/** * INTERNAL * Return a class loader * @return java.lang.ClassLoader */ public ClassLoader getClassLoader() { if (classLoader == null) { return org.eclipse.persistence.internal.helper.ConversionManager.getDefaultManager().getLoader(); } else { return classLoader; } }
/** * INTERNAL: * Load the class using the default managers class loader. * This is a thread based class loader by default. * This should be used to load all classes as Class.forName can only * see classes on the same classpath as the eclipselink.jar. */ public static Class loadClass(String className) { return (Class)getDefaultManager().convertObject(className, ClassConstants.CLASS); }
private JAXBContextState createContextState(Generator generator, JaxbClassLoader loader, Type[] typesToBeBound, Map properties) throws Exception { CoreProject proj = generator.generateProject(); ConversionManager conversionManager = null; if (classLoader != null) { conversionManager = new ConversionManager(); conversionManager.setLoader(loader); } else { conversionManager = ConversionManager.getDefaultManager(); } proj.convertClassNamesToClasses(conversionManager.getLoader()); // need to make sure that the java class is set properly on each // descriptor when using java classname - req'd for JOT api implementation for (Iterator<ClassDescriptor> descriptorIt = proj.getOrderedDescriptors().iterator(); descriptorIt.hasNext();) { ClassDescriptor descriptor = descriptorIt.next(); if (descriptor.getJavaClass() == null) { descriptor.setJavaClass(conversionManager.convertClassNameToClass(descriptor.getJavaClassName())); } } XMLPlatform platform = new SAXPlatform(); platform.getConversionManager().setLoader(loader); XMLContext xmlContext = new XMLContext((Project) proj, loader, sessionEventListeners()); ((XMLLogin) xmlContext.getSession().getDatasourceLogin()).setEqualNamespaceResolvers(true); return new JAXBContextState(xmlContext, generator, typesToBeBound, properties); }
/** * INTERNAL: */ protected SessionLog buildJavaLogConfig(JavaLogConfig javaLogConfig, AbstractSession session) { SessionLog javaLog = null; try { // use ConversionManager to avoid loading the JDK 1.4 class unless it is needed. ConversionManager conversionManager = new ConversionManager(); conversionManager.setLoader(getClass().getClassLoader()); javaLog = (SessionLog)((Class)conversionManager.convertObject("org.eclipse.persistence.logging.JavaLog", Class.class)).newInstance(); javaLog.setSession(session); } catch (Exception exception) { throw ValidationException.unableToLoadClass("org.eclipse.persistence.logging.JavaLog", exception); } // Process the common elements from LogConfig processLogConfig(javaLogConfig, javaLog); return javaLog; }
/** * Return the represented Java type. * @return Java type */ public Class<X> getJavaType() { if (javaClass == null){ javaClass = ConversionManager.getDefaultManager().convertClassNameToClass(javaClassName); } return this.javaClass; }
fileStream = (new ConversionManager()).getLoader().getResourceAsStream(fileOrResourceName); } else { fileStream = classLoader.getResourceAsStream(fileOrResourceName);
/** * The platform hold its own instance of conversion manager to allow customization. */ public ConversionManager getConversionManager() { // Lazy init for serialization. if (conversionManager == null) { //Clone the default to allow customers to easily override the conversion manager conversionManager = (ConversionManager)ConversionManager.getDefaultManager().clone(); } return conversionManager; }
public XMLContext(Collection projects, ClassLoader classLoader) { Iterator iterator = projects.iterator(); sessions = new ArrayList(projects.size()); descriptorsByQName = new HashMap(); descriptorsByGlobalType = new HashMap(); while(iterator.hasNext()) { Project project = (Project)iterator.next(); if ((project.getDatasourceLogin() == null) || !(project.getDatasourceLogin().getDatasourcePlatform() instanceof XMLPlatform)) { XMLPlatform platform = new SAXPlatform(); platform.getConversionManager().setLoader(classLoader); project.setLogin(new XMLLogin(platform)); } DatabaseSession session = project.createDatabaseSession(); // turn logging for this session off and leave the global session up // Note: setting level to SEVERE or WARNING will printout stacktraces for expected exceptions session.setLogLevel(SessionLog.OFF); // dont turn off global static logging //AbstractSessionLog.getLog().log(AbstractSessionLog.INFO, "ox_turn_global_logging_off", getClass()); //AbstractSessionLog.getLog().setLevel(AbstractSessionLog.OFF); setupDocumentPreservationPolicy(session); session.login(); sessions.add(session); storeXMLDescriptorsByQName(session); } }
private Class getObjectClass(Class primitiveClass) { return ConversionManager.getDefaultManager().getObjectClass(primitiveClass); }
ConversionManager cMgr = new ConversionManager(); cMgr.setLoader(loader);
/** * Returns the object class. If a class is primitive return its non primitive class */ public static Class getObjectClass(Class javaClass) { return ConversionManager.getObjectClass(javaClass); }
/** * INTERNAL: * Return the class loader for the session's application. * This loader should be able to load any application or EclipseLink class. */ public ClassLoader getLoader() { return getDatasourcePlatform().getConversionManager().getLoader(); }
public Class resolveClass(ObjectStreamClass classDesc) throws ClassNotFoundException, IOException { return m_conversionManager.convertClassNameToClass(classDesc.getName()); } }
String componentClassName = collectionType.getComponentType().getQualifiedName(); if (collectionType.getComponentType().isPrimitive()){ Class primitiveClass = XMLConversionManager.getDefaultManager().convertClassNameToClass(componentClassName); accessor.setComponentClass(primitiveClass); mapping.setAttributeAccessor(accessor); Class declaredClass = XMLConversionManager.getDefaultManager().getObjectClass(primitiveClass); mapping.setAttributeElementClass(declaredClass); } else {
protected Vector buildToStringVec() { return buildAllTypesToAClassVec(); }
/** * PUBLIC: * Return the list of Classes that can be converted to from the passed in javaClass. * @param javaClass - the class that is converted from * @return - a vector of classes */ public Vector getDataTypesConvertedFrom(Class javaClass) { return getConversionManager().getDataTypesConvertedFrom(javaClass); }
/** * PUBLIC: * Return the list of Classes that can be converted to from the passed in javaClass. * @param javaClass - the class that is converted from * @return - a vector of classes */ public Vector getDataTypesConvertedFrom(Class javaClass) { if (dataTypesConvertedFromAClass.isEmpty()) { buildDataTypesConvertedFromAClass(); } return (Vector)dataTypesConvertedFromAClass.get(javaClass); }