Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2007, Red Hat Middleware LLC, and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.jboss.managed.plugins.factory;
 
 import java.util.List;
 import java.util.Map;
 
A base InstanceClassFactory implementation that

Parameters:
<T> the instance type
Author(s):
Scott.Stark@jboss.org
Version:
$Revision: 70486 $
 
 public class AbstractInstanceClassFactory<T extends Serializable>
    implements InstanceClassFactory<T>
 {
   
The configuration
 
    private Configuration configuration = new PropertyConfiguration();
   
The meta value factory
 
    private MetaValueFactory metaValueFactory = MetaValueFactory.getInstance();
   
The instance to name transformers
 
 
    {
       return ;
    }
    public void setTransformers(Map<TypeInfoRuntimeComponentNameTransformertransformers)
    {
       this. = transformers;
    }
 
    {
       return ;
    }
    public void setConfiguration(Configuration configuration)
    {
       this. = configuration;
    }
 
    {
       return ;
    }
    public void setMetaValueFactory(MetaValueFactory metaValueFactory)
    {
       this. = metaValueFactory;
    }
 
   {
      return ;
   }
   public void setMof(ManagedObjectFactory mof)
   {
      this. = mof;
   }
   
   public Class<? extends SerializablegetManagedObjectClass(T attachment)
         throws ClassNotFoundException
   {
      return attachment.getClass();
   }
   public Object getComponentName(BeanInfo beanInfoManagedProperty property,
         T attachmentMetaValue value)
   {
      if (beanInfo != null && property != null && value != null)
      {
         String name = getPropertyName(property);
         PropertyInfo propertyInfo = beanInfo.getProperty(name);
         ManagementRuntimeRef componentRef = propertyInfo.getUnderlyingAnnotation(ManagementRuntimeRef.class);
         if (componentRef != null)
         {
            Object original = this.unwrapValue(beanInfopropertyvalue);
            try
            {
               Class<? extends RuntimeComponentNameTransformertClass = componentRef.transformer();
               RuntimeComponentNameTransformer transformer;
               if (tClass != ManagementRuntimeRef.DEFAULT_NAME_TRANSFORMER.class)
                  transformer = getComponentNameTransformer(.getTypeInfo(tClass));
               else
                  transformer = getComponentNameTransformer(propertyInfo.getType());
               return (transformer != null) ? transformer.transform(original) : original;
            }
            catch (Throwable t)
            {
               throw new UndeclaredThrowableException(t);
            }
         }
      }
      return null;
   }

   
Default InstanceClassFactory implementation simply returns the instance class.

Parameters:
instance the instance
Returns:
the class
   public Class<? extends SerializablegetManagedObjectClass(Object instance)
   {
      Serializable s = (Serializableinstance;
      return s.getClass();
   }
   public MetaValue getValue(BeanInfo beanInfoManagedProperty property, T object)
   {
      String name = getPropertyName(property);
      PropertyInfo propertyInfo = beanInfo.getProperty(name);
      Object value;
      try
      {
         value = propertyInfo.get(object);
      }
      catch (RuntimeException e)
      {
         throw e;
      }
      catch (Error e)
      {
         throw e;
      }
      catch (Throwable t)
      {
         throw new RuntimeException("Error getting property " + name + " for " + object.getClass().getName(), t);
      }
      if (value == null)
         return null;
      MetaType propertyType = property.getMetaType();
      if (. == propertyType)
      {
         if (value instanceof Serializable == false)
            throw new IllegalStateException("Object is not serializable: " + value.getClass().getName());
         // Look for a ManagementObjectRef
         ManagementObjectRef ref = (ManagementObjectRefproperty.getAnnotations().get(ManagementObjectRef.class.getName());
         String moName = (ref != null ? ref.name() : value.getClass().getName());
         String moNameType = (ref != null ? ref.type() : "");
         ManagedObject mo = .initManagedObject((SerializablevaluemoNamemoNameType);
      }
      else if (propertyType.isArray())
      {
         ArrayMetaType arrayType = ArrayMetaType.class.cast(propertyType);
         {
            Collection<?> cvalue = getAsCollection(value);
            ArrayValueSupport moArrayValue = new ArrayValueSupport(moType);
            List<GenericValueSupporttmp = new ArrayList<GenericValueSupport>();
            for(Object element : cvalue)
            {
               ManagedObject mo = .initManagedObject((Serializableelementnullnull);
            }
            GenericValueSupport[] mos = new GenericValueSupport[tmp.size()];
            moArrayValue.setValue(tmp.toArray(mos));
            return moArrayValue;
         }
      }
      else if (propertyType.isCollection())
      {
         CollectionMetaType collectionType = CollectionMetaType.class.cast(propertyType);
         if (. == collectionType.getElementType())
         {
            Collection<?> cvalue = getAsCollection(value);
            List<GenericValueSupporttmp = new ArrayList<GenericValueSupport>();
            for(Object element : cvalue)
            {
               ManagedObject mo = .initManagedObject((Serializableelementnullnull);
            }
            GenericValueSupport[] mos = new GenericValueSupport[tmp.size()];
            return new CollectionValueSupport(moTypetmp.toArray(mos));
         }
      }
      return .create(valuepropertyInfo.getType());
   }


   
Set a value

Parameters:
beanInfo the bean info
property the property
object the object
value the meta value
   public void setValue(BeanInfo beanInfoManagedProperty property, T objectMetaValue value)
   {
      String name = getPropertyName(property);
      PropertyInfo propertyInfo = beanInfo.getProperty(name);
      Object unwrapValue = unwrapValue(beanInfopropertyvalue);
      try
      {
         setValue(beanInfopropertyInfoobjectunwrapValue);
      }
      catch(Throwable t)
      {
         throw new UndeclaredThrowableException(t);
      }
   }

   
Get component name transformer.

Parameters:
type the type info
Returns:
transformer instance
Throws:
java.lang.Throwable for any error
   {
      synchronized()
      {
         RuntimeComponentNameTransformer transformer = .get(type);
         if (transformer != null)
            return transformer;
         if (rcntType.isAssignableFrom(type))
         {
            BeanInfo beanInfo = .getBeanInfo(type);
            RuntimeComponentNameTransformer newTransformer = (RuntimeComponentNameTransformer)beanInfo.newInstance();
            .put(typenewTransformer);
            return newTransformer;
         }
         return null;
      }
   }
   protected Object unwrapValue(BeanInfo beanInfoManagedProperty propertyMetaValue value)
   {
      String name = getPropertyName(property);
      PropertyInfo propertyInfo = beanInfo.getProperty(name);
      Object unwrapValue = .unwrap(valuepropertyInfo.getType());
      return unwrapValue;
   }
   protected void setValue(BeanInfo beanInfoPropertyInfo propertyInfoObject objectObject unwrapValue)
      throws Throwable
   {
      propertyInfo.set(objectunwrapValue);
   }
   protected Collection<?> getAsCollection(Object value)
   {
      ifvalue.getClass().isArray() )
         return Arrays.asList(value);
      else if (value instanceof Collection)
         return Collection.class.cast(value);
      return null;
   }

   
Get the property name.

Parameters:
property managed property
Returns:
property name
   protected String getPropertyName(ManagedProperty property)
   {
      // First look to the mapped name
      String name = property.getMappedName();
      if (name == null)
         property.getName();
      return name;
   }
New to GrepCode? Check out our FAQ X