org.jdesktop.beansbinding.ext.BeanAdapterFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of swixml Show documentation
GUI generating engine for Java applications
The newest version!
/*
 * Copyright (C) 2006-2007 Sun Microsystems, Inc. All rights reserved. Use is
 * subject to license terms.
 */

package org.jdesktop.beansbinding.ext;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.lang.ref.WeakReference;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.beans.*;

public final class BeanAdapterFactory {
    private static final BeanAdapterFactory INSTANCE =  new BeanAdapterFactory();
    private final Map> vendedAdapters;
    private final List providers;
    private final Set classLoaders;
    private final Set serviceURLs;

    public static Object getAdapter(Object source, String property) {
        return INSTANCE.getAdapter0(source, property);
    }

    public static List getAdapterPropertyDescriptors(Class type) {
        return INSTANCE.getAdapterPropertyDescriptors0(type);
    }

    public BeanAdapterFactory() {
        this.providers = new ArrayList();
        classLoaders = new HashSet();
        serviceURLs = new HashSet();
        vendedAdapters = new WeakHashMap>();
    }

    private void loadProvidersIfNecessary() {
        ClassLoader currentLoader = Thread.currentThread().getContextClassLoader();
        if (!classLoaders.contains(currentLoader)) {
            classLoaders.add(currentLoader);
            loadProviders(currentLoader);
        }
    }
    
    private void loadProviders(ClassLoader classLoader) {
        // PENDING: this needs to be rewriten in terms of ServiceLoader
        String serviceName = "META-INF/services/" + 
                BeanAdapterProvider.class.getName();
        try {
            Enumeration urls = classLoader.getResources(serviceName);
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                if (!serviceURLs.contains(url)) {
                    serviceURLs.add(url);
                    addProviders(url);
                }
            }
        } catch (IOException ex) {
        }
    }
    
    private void addProviders(URL url) {
        InputStream inputStream = null;
        BufferedReader reader = null;
        try {
            inputStream = url.openStream();
            reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
            String line;
            while ((line = reader.readLine()) != null) {
                try {
                    providers.add((BeanAdapterProvider)Class.forName(line).newInstance());
                } catch (IllegalAccessException ex) {
                } catch (InstantiationException ex) {
                } catch (ClassNotFoundException ex) {
                }
            }
        } catch (UnsupportedEncodingException ex) {
        } catch (IOException ex) {
        }
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException ex) {
            }
        }
    }

    public Object getAdapter0(Object source, String property) {
        if (source == null || property == null) {
            throw new IllegalArgumentException();
        }
        loadProvidersIfNecessary();
        property = property.intern();
        BeanAdapterProvider provider = getProvider(source, property);
        if (provider != null) {
            List adapters = vendedAdapters.get(source);
            if (adapters != null) {
                for (int i = adapters.size() - 1; i >= 0; i--) {
                    VendedAdapter vendedAdapter = adapters.get(i);
                    Object adapter = vendedAdapter.getAdapter();
                    if (adapter == null) {
                        vendedAdapters.remove(i);
                    } else if (vendedAdapter.getProvider() == provider && vendedAdapter.getProperty() == property) {
                        return adapter;
                    }
                }
            } else {
                adapters = new ArrayList(1);
                vendedAdapters.put(source, adapters);
            }
            Object adapter = provider.createAdapter(source, property);
            adapters.add(new VendedAdapter(property, provider, adapter));
            return adapter;
        }
        return null;
    }
    
    private BeanAdapterProvider getProvider(Object source, String property) {
        Class type = source.getClass();
        for (BeanAdapterProvider provider : providers) {
            if (provider.providesAdapter(type, property)) {
                return provider;
            }
        }
        return null;
    }

        private List getDescriptors(Class type) {
            BeanInfo info = null;
            try {
                info = Introspector.getBeanInfo(type);
            } catch (Exception ex) {
            }
            if (info == null) {
                return Collections.emptyList();
            }
            ArrayList list = new ArrayList(
                    info.getPropertyDescriptors().length);
            for (PropertyDescriptor pd: info.getPropertyDescriptors()) {
                // PENDING: The following properties come from EL, are they
                // needed?
                if (pd.getPropertyType() != null) {
                    pd.setValue("type", pd.getPropertyType());
                }
                pd.setValue("resolvableAtDesignTime", Boolean.TRUE);
                list.add(pd);
            }
            return list;
        }

    private static BeanInfo getBeanInfo(Class type) {
        try {
            return Introspector.getBeanInfo(type);
        } catch (IntrospectionException ie) {
            return null;
        }
    }

    private List getAdapterPropertyDescriptors0(Class type) {
        if (type == null) {
            throw new IllegalArgumentException("Type must be non-null");
        }

        loadProvidersIfNecessary();
        
        ArrayList des = new ArrayList();

        for (BeanAdapterProvider provider : providers) {
            Class pdType = provider.getAdapterClass(type);
            if (pdType != null) {
                BeanInfo info = getBeanInfo(pdType);
                if (info != null) {
                    PropertyDescriptor[] pds = info.getPropertyDescriptors();
                    if (pds != null) {
                        for (PropertyDescriptor pd : pds) {
                            if (provider.providesAdapter(type, pd.getName())) {
                                des.add(pd);
                            }
                        }
                    }
                }
            }
        }
        
        return des;
    }
    
    private static final class VendedAdapter {
        private final BeanAdapterProvider provider;
        private final String property;
        private final WeakReference