Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2005,2009 Ivan SZKIBA
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.ini4j.spi;
 
 
 
 public abstract class AbstractBeanInvocationHandler implements InvocationHandler
 {
     private static final String PROPERTY_CHANGE_LISTENER = "PropertyChangeListener";
     private static final String VETOABLE_CHANGE_LISTENER = "VetoableChangeListener";
     private static final String ADD_PREFIX = "add";
     private static final String READ_PREFIX = "get";
     private static final String REMOVE_PREFIX = "remove";
     private static final String READ_BOOLEAN_PREFIX = "is";
     private static final String WRITE_PREFIX = "set";
     private static final String HAS_PREFIX = "has";
 
     private static enum Prefix
     {
         READ(),
         READ_BOOLEAN(),
         WRITE(),
         ADD_CHANGE( + ),
         ADD_VETO( + ),
         REMOVE_CHANGE( + ),
         REMOVE_VETO( + ),
         HAS();
         private int _len;
         private String _value;
 
         private Prefix(String value)
         {
              = value;
              = value.length();
         }
 
         public static Prefix parse(String str)
         {
             Prefix ret = null;
 
             for (Prefix p : values())
             {
                 if (str.startsWith(p.getValue()))
                 {
                     ret = p;
 
                     break;
                 }
             }
 
             return ret;
         }
 
         public String getTail(String input)
         {
             return Introspector.decapitalize(input.substring());
         }
 
         public String getValue()
         {
             return ;
         }
     }
 
     private PropertyChangeSupport _pcSupport;
     private Object _proxy;
     private VetoableChangeSupport _vcSupport;
 
     @Override public Object invoke(Object proxyMethod methodObject[] argsthrows PropertyVetoException
     {
         Object ret = null;
         Prefix prefix = Prefix.parse(method.getName());
 
         if (prefix != null)
         {
             String tail = prefix.getTail(method.getName());
 
            updateProxy(proxy);
            switch (prefix)
            {
                case :
                    ret = getProperty(prefix.getTail(method.getName()), method.getReturnType());
                    break;
                case :
                    ret = getProperty(prefix.getTail(method.getName()), method.getReturnType());
                    break;
                case :
                    setProperty(tailargs[0], method.getParameterTypes()[0]);
                    break;
                case :
                    ret = Boolean.valueOf(hasProperty(prefix.getTail(method.getName())));
                    break;
                case :
                    addPropertyChangeListener((Stringargs[0], (PropertyChangeListenerargs[1]);
                    break;
                case :
                    addVetoableChangeListener((Stringargs[0], (VetoableChangeListenerargs[1]);
                    break;
                case :
                    removePropertyChangeListener((Stringargs[0], (PropertyChangeListenerargs[1]);
                    break;
                case :
                    removeVetoableChangeListener((Stringargs[0], (VetoableChangeListenerargs[1]);
                    break;
                default:
                    break;
            }
        }
        return ret;
    }
    protected abstract Object getPropertySpi(String propertyClass<?> clazz);
    protected abstract void setPropertySpi(String propertyObject valueClass<?> clazz);
    protected abstract boolean hasPropertySpi(String property);
    protected synchronized Object getProperty(String propertyClass<?> clazz)
    {
        Object o;
        try
        {
            o = getPropertySpi(propertyclazz);
            if (o == null)
            {
                o = zero(clazz);
            }
            else if (clazz.isArray() && (o instanceof String[]) && !clazz.equals(String[].class))
            {
                String[] str = (String[]) o;
                o = Array.newInstance(clazz.getComponentType(), str.length);
                for (int i = 0; i < str.lengthi++)
                {
                    Array.set(oiparse(str[i], clazz.getComponentType()));
                }
            }
            else if ((o instanceof String) && !clazz.equals(String.class))
            {
                o = parse((Stringoclazz);
            }
        }
        catch (Exception x)
        {
            o = zero(clazz);
        }
        return o;
    }
    protected synchronized void setProperty(String propertyObject valueClass<?> clazzthrows PropertyVetoException
    {
        boolean pc = ( != null) && .hasListeners(property);
        boolean vc = ( != null) && .hasListeners(property);
        Object oldVal = null;
        Object newVal = ((value != null) && clazz.equals(String.class) && !(value instanceof String)) ? value.toString() : value;
        if (pc || vc)
        {
            oldVal = getProperty(propertyclazz);
        }
        if (vc)
        {
            fireVetoableChange(propertyoldValvalue);
        }
        setPropertySpi(propertynewValclazz);
        if (pc)
        {
            firePropertyChange(propertyoldValvalue);
        }
    }
    protected synchronized Object getProxy()
    {
        return ;
    }
    protected synchronized void addPropertyChangeListener(String propertyPropertyChangeListener listener)
    {
        if ( == null)
        {
             = new PropertyChangeSupport();
        }
        .addPropertyChangeListener(propertylistener);
    }
    protected synchronized void addVetoableChangeListener(String propertyVetoableChangeListener listener)
    {
        if ( == null)
        {
             = new VetoableChangeSupport();
        }
        .addVetoableChangeListener(propertylistener);
    }
    protected synchronized void firePropertyChange(String propertyObject oldValueObject newValue)
    {
        if ( != null)
        {
            .firePropertyChange(propertyoldValuenewValue);
        }
    }
    protected synchronized void fireVetoableChange(String propertyObject oldValueObject newValuethrows PropertyVetoException
    {
        if ( != null)
        {
            .fireVetoableChange(propertyoldValuenewValue);
        }
    }
    protected synchronized boolean hasProperty(String property)
    {
        boolean ret;
        try
        {
            ret = hasPropertySpi(property);
        }
        catch (Exception x)
        {
            ret = false;
        }
        return ret;
    }
    protected Object parse(String valueClass<?> clazzthrows IllegalArgumentException
    {
        return BeanTool.getInstance().parse(valueclazz);
    }
    protected synchronized void removePropertyChangeListener(String propertyPropertyChangeListener listener)
    {
        if ( != null)
        {
            .removePropertyChangeListener(propertylistener);
        }
    }
    protected synchronized void removeVetoableChangeListener(String propertyVetoableChangeListener listener)
    {
        if ( != null)
        {
            .removeVetoableChangeListener(propertylistener);
        }
    }
    protected Object zero(Class<?> clazz)
    {
        return BeanTool.getInstance().zero(clazz);
    }
    private synchronized void updateProxy(Object value)
    {
        if ( == null)
        {
             = value;
        }
    }
New to GrepCode? Check out our FAQ X