+++ /dev/null
-package org.opendaylight.controller.northbound.commons.query;
-
-import java.beans.BeanInfo;
-import java.beans.IntrospectionException;
-import java.beans.Introspector;
-import java.beans.PropertyDescriptor;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlAttribute;
-import javax.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlElementRef;
-import javax.xml.bind.annotation.XmlElementWrapper;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlTransient;
-import javax.xml.bind.annotation.XmlType;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * A wrapper over a JAXB type to allow traversal of the object graph and
- * search for specific values in the object tree.
- */
-/*package*/ class TypeInfo {
-
- public static final Logger LOGGER = LoggerFactory.getLogger(TypeInfo.class);
- public static final String DEFAULT_NAME = "##default";
-
- protected final String _name; // the jaxb name
- protected Class<?> _class; // jaxb type class
- protected final XmlAccessType _accessType; // jaxb access type
- protected final Accessor _accessor; // accessor to access object value
- protected Map<String,TypeInfo> _types = new HashMap<String,TypeInfo>();
- protected volatile boolean _explored = false;
- /**
- * Create a TypeInfo with a name and a class type. The accessor will be null
- * for a root node.
- */
- protected TypeInfo(String name, Class<?> clz, Accessor accessor) {
- _name = name;
- _class = clz;
- _accessor = accessor;
- XmlAccessorType accessorType = null;
- if(clz == null) {
- throw new NullPointerException("Type class can not be null");
- }
- accessorType = clz.getAnnotation(XmlAccessorType.class);
- _accessType = (accessorType == null ?
- XmlAccessType.PUBLIC_MEMBER : accessorType.value());
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("Created type info name:{} type:{}", _name, _class);
- }
- }
-
- /**
- * @return the Accessor to access the value
- */
- public final Accessor getAccessor() {
- return _accessor;
- }
-
- /**
- * @return get the child by name
- */
- public final TypeInfo getChild(String name) {
- return _types.get(name);
- }
-
- public TypeInfo getCollectionChild(Class<?> childType) {
- explore();
- for (TypeInfo ti : _types.values()) {
- if (Collection.class.isAssignableFrom(ti.getType())) {
- ParameterizedType p = (ParameterizedType)
- ti.getAccessor().getGenericType();
- Type[] pts = p.getActualTypeArguments();
- if (pts.length == 1 && pts[0].equals(childType)) {
- return ti;
- }
- }
- }
- return null;
- }
-
- public Class getType() {
- return _class;
- }
-
- public String getName() {
- return _name;
- }
-
- /**
- * @return the object value by a selector query
- */
- public Object retrieve(Object target, String[] query, int index)
- throws QueryException {
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("retrieve: {}/{} type:{}", index, query.length, target.getClass());
- }
- if (index >= query.length) {
- return null;
- }
- explore();
- if (!target.getClass().equals(_class)) {
- if (_class.isAssignableFrom(target.getClass())) {
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug("Handling subtype {} of {} ", target.getClass(), _class);
- }
- // explore the subtype
- TypeInfo subTypeInfo = new TypeInfo(getRootName(target.getClass()),
- target.getClass(), _accessor);
- return subTypeInfo.retrieve(target, query, index);
- } else {
- // non compatible object; bail out
- return null;
- }
- }
- TypeInfo child = getChild(query[index]);
- if (child == null) {
- return null;
- }
- target = child.getAccessor().getValue(target);
- if (index+1 == query.length) {
- // match found
- return target;
- }
- return child.retrieve(target, query, index+1);
- }
-
- /**
- * Explore the type info for children.
- */
- public synchronized void explore() {
- if (_explored) {
- return;
- }
- for (Class<?> c = _class; c != null; c = c.getSuperclass()) {
- if (c.equals(Object.class)) {
- break;
- }
- // Currently only fields and methods annotated with JAXB annotations are
- // considered as valid for search purposes.
- //check methods first
- for (Method m : c.getDeclaredMethods()) {
- String tn = getTypeName(m, _accessType);
- if (tn != null) {
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug(
- "exploring type: {} name: {} method: {}",
- _class.getSimpleName(), tn, m);
- }
- _types.put(tn, createTypeInfo(tn, new Accessor(m)));
- }
- }
- for (Field f : c.getDeclaredFields()) {
- String tn = getTypeName(f, _accessType);
- if (tn != null) {
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug(
- "exploring type: {} name: {} field: {}",
- _class.getSimpleName(), tn, f);
- }
- _types.put(tn, createTypeInfo(tn, new Accessor(f)));
- }
- }
- }
- _explored = true;
- }
-
- public static final String getTypeName(Field f, XmlAccessType access) {
- // ignore static, transient and xmltransient fields
- if (Modifier.isTransient(f.getModifiers()) ||
- Modifier.isStatic(f.getModifiers()) ||
- f.getAnnotation(XmlTransient.class) != null ) {
- return null;
- }
- // try to read annotation
- String name = getTypeName(f.getAnnotations(), f.getName());
- if (name != null) return name;
- // no annotation present check accesstype
- else if (access == XmlAccessType.NONE) { // none return name
- return name;
- } else if (access == XmlAccessType.FIELD) {
- // return field name if no annotation present
- return f.getName();
- } else if (access == XmlAccessType.PUBLIC_MEMBER
- && Modifier.isPublic(f.getModifiers())) { // look for public access
- return f.getName();
- }
- // return annotated name ( if any )
- return null;
- }
-
- public static final String getTypeName(Method m, XmlAccessType access) {
- // ignore static, transient and xmltransient fields
- if (Modifier.isStatic(m.getModifiers()) ||
- m.getAnnotation(XmlTransient.class) != null ) {
- return null;
- }
- // try to read annotation
- String name = getTypeName(m.getAnnotations(), m.getName());
- if (name != null) return name;
- //check acces type
- else if (access == XmlAccessType.NONE) { // none return name
- return name;
- } else if (access == XmlAccessType.PROPERTY) {
- // return bean property name if no annotation present
- return getBeanPropertyName(m);
- } else if (access == XmlAccessType.PUBLIC_MEMBER
- && Modifier.isPublic(m.getModifiers())) { // look for public access
- return getBeanPropertyName(m);
- }
- return null;
- }
-
- private static String getBeanPropertyName(Method m){
- try
- {
- Class<?> clazz=m.getDeclaringClass();
- BeanInfo info = Introspector.getBeanInfo(clazz);
- PropertyDescriptor[] props = info.getPropertyDescriptors();
- for (PropertyDescriptor pd : props)
- {
- if (m.equals(pd.getReadMethod())) {
- return pd.getName();
- }
- }
- }
- catch (IntrospectionException e)
- {
- LOGGER.error("Could not read bean property name for method = {}",
- m.getName(), e);
- }
- return null;
- }
-
- public static TypeInfo createRoot(String name, Class<?> clz) {
- // root is always a composite type
- // FIXME assert its a JAXB type
- XmlRootElement root = clz.getAnnotation(XmlRootElement.class);
- if (root == null) {
- throw new IllegalArgumentException("Not a JAXB type: " + clz);
- }
- if (name == null) {
- name = getRootName(clz);
- }
- return new TypeInfo(name, clz, null);
- }
-
- public static TypeInfo createTypeInfo(String name, Accessor accessor) {
- if (accessor.getAccessibleObject().getAnnotation(XmlElementWrapper.class) != null) {
- //XmlElementWrapperType
- return new WrapperTypeInfo(name, accessor);
- } else if (Collection.class.isAssignableFrom(accessor.getType())) {
- // collection type
- return new IteratableTypeInfo(name, accessor);
- }
- return new TypeInfo(name, accessor.getType(), accessor);
- }
-
- public static String getRootName(Class<?> cls) {
- XmlRootElement root = cls.getAnnotation(XmlRootElement.class);
- if (root == null) {
- return null;
- }
- String rootName = root.name();
- if (DEFAULT_NAME.equals(rootName)) {
- String clsName = cls.getSimpleName();
- rootName = Character.toLowerCase(clsName.charAt(0)) + clsName.substring(1);
- }
- return rootName;
- }
-
- protected static String getTypeName(Annotation[] annotations, String dflt) {
- String name = null;
- for (Annotation a : annotations) {
- if (a.annotationType() == XmlAttribute.class) {
- name = ((XmlAttribute)a).name();
- } else if (a.annotationType() == XmlElement.class) {
- name = ((XmlElement)a).name();
- } else if (a.annotationType() == XmlElementRef.class) {
- name = ((XmlElementRef)a).name();
- } else if (a.annotationType() == XmlElementWrapper.class) {
- name = ((XmlElementWrapper)a).name();
- // break the loop as we don't want name to be overwritten by XmlElement
- break;
- } else if (a.annotationType() == XmlType.class) {
- name = ((XmlType)a).name();
- } else if (a.annotationType() == XmlTransient.class) {
- // transient type
- return null;
- }
- }
- if (DEFAULT_NAME.equals(name)) {
- return dflt;
- }
- return name;
- }
-
- @Override
- public String toString() {
- return " TypeInfo [_name=" + _name + ", _class=" + _class
- + ", _accessType=" + _accessType + ", _accessor=" + _accessor
- + ", _types=" + _types + ", _explored=" + _explored + " ] ";
- }
-}
Code Review / controller.git / blobdiff