{
// Ignore the "class" property
if ("class".equals(propertyInfo.getName()))
continue;
ManagementProperty managementProperty = getAnnotation(ManagementProperty.class, propertyInfo, metaData);
ManagementObjectID id = getAnnotation(ManagementObjectID.class, propertyInfo, metaData);
ManagementObjectRef ref = getAnnotation(ManagementObjectRef.class, propertyInfo, metaData);
ManagementRuntimeRef runtimeRef = getAnnotation(ManagementRuntimeRef.class, propertyInfo, metaData);
RunStateProperty rsp = getAnnotation(RunStateProperty.class, propertyInfo, metaData);
Masked masked = getAnnotation(Masked.class, propertyInfo, metaData);
DefaultValueBuilderFactory defaultsFactory = getAnnotation(DefaultValueBuilderFactory.class, propertyInfo, metaData);
HashMap<String, Annotation> propAnnotations = new HashMap<String, Annotation>();
if (managementProperty != null)
propAnnotations.put(ManagementProperty.class.getName(), managementProperty);
if (id != null)
{
propAnnotations.put(ManagementObjectID.class.getName(), id);
// This overrides the MO nameType
nameType = id.type();
}
if (ref != null)
propAnnotations.put(ManagementObjectRef.class.getName(), ref);
if (runtimeRef != null)
propAnnotations.put(ManagementRuntimeRef.class.getName(), runtimeRef);
if (rsp != null)
propAnnotations.put(RunStateProperty.class.getName(), rsp);
if (masked != null)
propAnnotations.put(Masked.class.getName(), masked);
// Check whether this property should be included
boolean includeProperty = false;
switch(propertyType)
{
// Only if the property as a ManagementProperty
case EXPLICIT:
includeProperty = managementProperty != null &&
(managementProperty.ignored() == false);
break;
// Only if the property is listed in the classProperties
case CLASS:
includeProperty = classProperties.contains(propertyInfo.getName());
break;
// Only if the property is listed in the classProperties
case CLASS_AND_EXPLICIT:
includeProperty = classProperties.contains(propertyInfo.getName())
|| (managementProperty != null && managementProperty.ignored() == false);
break;
// Any property that is not ignored
case ALL:
includeProperty = managementProperty == null
|| managementProperty.ignored() == false;
break;
}
if (includeProperty)
{
Fields fields = null;
Class<? extends Fields> factory = moFieldsFactory;
FieldsFactory ff = getAnnotation(FieldsFactory.class, propertyInfo, metaData);
if(ff != null)
factory = ff.value();
if (factory != null)
{
try
{
fields = factory.newInstance();
}
catch (Exception e)
{
log.debug("Failed to created Fields", e);
}
}
if (fields == null)
fields = new DefaultFieldsImpl();
if( propertyInfo instanceof Serializable )
{
Serializable info = Serializable.class.cast(propertyInfo);
fields.setField(Fields.PROPERTY_INFO, info);
}
String propertyName = propertyInfo.getName();
if (managementProperty != null)
propertyName = managementProperty.name();
if( propertyName.length() == 0 )
propertyName = propertyInfo.getName();
fields.setField(Fields.NAME, propertyName);
// This should probably always the the propertyInfo name?
String mappedName = propertyInfo.getName();
if (managementProperty != null)
mappedName = managementProperty.mappedName();
if( mappedName.length() == 0 )
mappedName = propertyInfo.getName();
fields.setField(Fields.MAPPED_NAME, mappedName);
String description = ManagementConstants.GENERATED;
if (managementProperty != null)
description = managementProperty.description();
if (description.equals(ManagementConstants.GENERATED))
description = propertyName;
fields.setField(Fields.DESCRIPTION, description);
if (trace)
{
log.trace("Building MangedProperty(name="+propertyName
+",mappedName="+mappedName
+") ,annotations="+propAnnotations);
}
boolean mandatory = false;
if (managementProperty != null)
mandatory = managementProperty.mandatory();
if (mandatory)
fields.setField(Fields.MANDATORY, Boolean.TRUE);
boolean readOnly = propertyInfo.isWritable() == false;
if (readOnly == false && managementProperty != null)
readOnly = managementProperty.readOnly();
if (readOnly)
fields.setField(Fields.READ_ONLY, Boolean.TRUE);
boolean managed = false;
if (managementProperty != null)
managed = managementProperty.managed();
// View Use
if (managementProperty != null)
{
ViewUse[] use = managementProperty.use();
fields.setField(Fields.VIEW_USE, use);
}
// ActivationPolicy
ActivationPolicy apolicy = ActivationPolicy.IMMEDIATE;
if (managementProperty != null)
{
apolicy = managementProperty.activationPolicy();
}
fields.setField(Fields.ACTIVATION_POLICY, apolicy);
// The managed property type
MetaMapper[] mapperReturn = {null};
MetaType metaType = this.getMetaType(propertyInfo, propertyInfo.getType(), metaData, false, mapperReturn);
// Determine meta type based on property type
if(metaType == null)
{
if (managed)
{
TypeInfo typeInfo = propertyInfo.getType();
if(typeInfo.isArray())
metaType = new ArrayMetaType(1, MANAGED_OBJECT_META_TYPE);
else if (typeInfo.isCollection())
metaType = new CollectionMetaType(typeInfo.getName(), MANAGED_OBJECT_META_TYPE);
else
metaType = MANAGED_OBJECT_META_TYPE;
}
else
{
metaType = metaTypeFactory.resolve(propertyInfo.getType());
}
}
fields.setField(Fields.META_TYPE, metaType);
// Default value
if(managementProperty != null)
{
String defaultValue = managementProperty.defaultValue();
if(defaultValue.length() > 0)
{
try
{
// Check for a DefaultValueBuilderFactory