How to use org.codehaus.jackson.map.introspect

/**
 * @since 1.9
 */
public POJOPropertiesCollector collectProperties(MapperConfig<?> config,
    JavaType type, MixInResolver r, boolean forSerialization)
{
  AnnotatedClass ac = classWithCreators(config, type, r);
  ac.resolveMemberMethods(MINIMAL_FILTER);
  ac.resolveFields();
  return constructPropertyCollector(config, ac, type, forSerialization).collect();
}

private AnnotationMap _mergeAnnotations(int index, Node<? extends AnnotatedMember>... nodes)
{
  AnnotationMap ann = nodes[index].value.getAllAnnotations();
  ++index;
  for (; index < nodes.length; ++index) {
    if (nodes[index] != null) {
     return AnnotationMap.merge(ann, _mergeAnnotations(index, nodes));
    }
  }
  return ann;
}

@Override
public BasicBeanDescription forDeserialization(DeserializationConfig cfg,
    JavaType type, MixInResolver r)
{
  // minor optimization: for JDK types do minimal introspection
  BasicBeanDescription desc = _findCachedDesc(type);
  if (desc == null) {
    desc = BasicBeanDescription.forDeserialization(collectProperties(cfg, type, r, false));
  }
  return desc;
}

/**
 * Method called to remove specified method, assuming
 * it exists in the Map
 */
public AnnotatedMethod remove(AnnotatedMethod am)
{
  return remove(am.getAnnotated());
}

@Override
public BasicBeanDescription forSerialization(SerializationConfig cfg,
    JavaType type, MixInResolver r)
{
  // minor optimization: for JDK types do minimal introspection
  BasicBeanDescription desc = _findCachedDesc(type);
  if (desc == null) {
    desc = BasicBeanDescription.forSerialization(collectProperties(cfg, type, r, true));
  }
  return desc;
}

/**
 * Fluent factory method that will construct a new instance that uses
 * annotations from specified {@link Annotated} as fallback annotations
 * 
 * @since 1.9
 */
public final Annotated withFallBackAnnotationsFrom(Annotated annotated) {
  return withAnnotations(AnnotationMap.merge(getAllAnnotations(), annotated.getAllAnnotations()));
}

@Override
public boolean isSetterVisible(AnnotatedMethod m) {
  return isSetterVisible(m.getAnnotated());
}

@Override
public boolean isIsGetterVisible(AnnotatedMethod m) {
  return isIsGetterVisible(m.getAnnotated());
}

@Override
public boolean isGetterVisible(AnnotatedMethod m) {
  return isGetterVisible(m.getAnnotated());
}

@Override
public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
  VisibilityChecker<?> checker)
{
  JsonAutoDetect ann = ac.getAnnotation(JsonAutoDetect.class);
  return (ann == null) ? checker : checker.with(ann);
}

public final AnnotatedParameter getParameter(int index) {
  return new AnnotatedParameter(this, getParameterType(index),
      _paramAnnotations[index], index);
}

@Override
public boolean isCreatorVisible(AnnotatedMember m) {
  return isCreatorVisible(m.getMember());
}

@Override
public boolean isFieldVisible(AnnotatedField f) {
  return isFieldVisible(f.getAnnotated());
}

@Override
public <A extends Annotation> A getAnnotation(Class<A> acls)
{
  if (_classAnnotations == null) {
    return null;
  }
  return _classAnnotations.get(acls);
}

@Override
public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config,
    AnnotatedClass ac, JavaType baseType)
{
  return _findTypeResolver(config, ac, baseType);
}

/**
 * Method for adding all property members from specified collector into
 * this collector.
 */
public void addAll(POJOPropertyBuilder src)
{
  _fields = merge(_fields, src._fields);
  _ctorParameters = merge(_ctorParameters, src._ctorParameters);
  _getters= merge(_getters, src._getters);
  _setters = merge(_setters, src._setters);
}

private <T> Node<T> _removeIgnored(Node<T> node)
{
  if (node == null) {
    return node;
  }
  return node.withoutIgnored();
}

public boolean anyExplicitNames() {
  return _anyExplicitNames(_fields)
      || _anyExplicitNames(_getters)
      || _anyExplicitNames(_setters)
      || _anyExplicitNames(_ctorParameters)
      ;
}

public boolean anyDeserializeIgnorals() {
  return _anyIgnorals(_fields)
    || _anyIgnorals(_setters)
    || _anyIgnorals(_ctorParameters)
  ;
}

@Override
public BasicBeanDescription forCreation(DeserializationConfig cfg,
    JavaType type, MixInResolver r)
{
  BasicBeanDescription desc = _findCachedDesc(type);
  if (desc == null) {
    desc = BasicBeanDescription.forDeserialization(collectProperties(cfg, type, r, false));
  }
  return desc;
}