How to use

isFactoryMethod

method

in

org.codehaus.jackson.map.introspect.BasicBeanDescription

public List<AnnotatedMethod> getFactoryMethods()
{
  // must filter out anything that clearly is not a factory method
  List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
  if (candidates.isEmpty()) {
    return candidates;
  }
  ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
  for (AnnotatedMethod am : candidates) {
    if (isFactoryMethod(am)) {
      result.add(am);
    }
  }
  return result;
}

/**
 * Method that can be called to find if introspected class declares
 * a static "valueOf" factory method that returns an instance of
 * introspected type, given one of acceptable types.
 *
 * @param expArgTypes Types that the matching single argument factory
 *   method can take: will also accept super types of these types
 *   (ie. arg just has to be assignable from expArgType)
 */
public Method findFactoryMethod(Class<?>... expArgTypes)
{
  // So, of all single-arg static methods:
  for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
    if (isFactoryMethod(am)) {
      // And must take one of expected arg types (or supertype)
      Class<?> actualArgType = am.getParameterClass(0);
      for (Class<?> expArgType : expArgTypes) {
        // And one that matches what we would pass in
        if (actualArgType.isAssignableFrom(expArgType)) {
          return am.getAnnotated();
        }
      }
    }
  }
  return null;
}

public List<AnnotatedMethod> getFactoryMethods()
{
  // must filter out anything that clearly is not a factory method
  List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
  if (candidates.isEmpty()) {
    return candidates;
  }
  ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
  for (AnnotatedMethod am : candidates) {
    if (isFactoryMethod(am)) {
      result.add(am);
    }
  }
  return result;
}

/**
 * Method that can be called to find if introspected class declares
 * a static "valueOf" factory method that returns an instance of
 * introspected type, given one of acceptable types.
 *
 * @param expArgTypes Types that the matching single argument factory
 *   method can take: will also accept super types of these types
 *   (ie. arg just has to be assignable from expArgType)
 */
public Method findFactoryMethod(Class<?>... expArgTypes)
{
  // So, of all single-arg static methods:
  for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
    if (isFactoryMethod(am)) {
      // And must take one of expected arg types (or supertype)
      Class<?> actualArgType = am.getParameterClass(0);
      for (Class<?> expArgType : expArgTypes) {
        // And one that matches what we would pass in
        if (actualArgType.isAssignableFrom(expArgType)) {
          return am.getAnnotated();
        }
      }
    }
  }
  return null;
}

public List<AnnotatedMethod> getFactoryMethods()
{
  // must filter out anything that clearly is not a factory method
  List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
  if (candidates.isEmpty()) {
    return candidates;
  }
  ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
  for (AnnotatedMethod am : candidates) {
    if (isFactoryMethod(am)) {
      result.add(am);
    }
  }
  return result;
}

public List<AnnotatedMethod> getFactoryMethods()
{
  // must filter out anything that clearly is not a factory method
  List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
  if (candidates.isEmpty()) {
    return candidates;
  }
  ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
  for (AnnotatedMethod am : candidates) {
    if (isFactoryMethod(am)) {
      result.add(am);
    }
  }
  return result;
}

public List<AnnotatedMethod> getFactoryMethods()
{
  // must filter out anything that clearly is not a factory method
  List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
  if (candidates.isEmpty()) {
    return candidates;
  }
  ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
  for (AnnotatedMethod am : candidates) {
    if (isFactoryMethod(am)) {
      result.add(am);
    }
  }
  return result;
}

public List<AnnotatedMethod> getFactoryMethods()
{
  // must filter out anything that clearly is not a factory method
  List<AnnotatedMethod> candidates = _classInfo.getStaticMethods();
  if (candidates.isEmpty()) {
    return candidates;
  }
  ArrayList<AnnotatedMethod> result = new ArrayList<AnnotatedMethod>();
  for (AnnotatedMethod am : candidates) {
    if (isFactoryMethod(am)) {
      result.add(am);
    }
  }
  return result;
}

/**
 * Method that can be called to find if introspected class declares
 * a static "valueOf" factory method that returns an instance of
 * introspected type, given one of acceptable types.
 *
 * @param expArgTypes Types that the matching single argument factory
 *   method can take: will also accept super types of these types
 *   (ie. arg just has to be assignable from expArgType)
 */
public Method findFactoryMethod(Class<?>... expArgTypes)
{
  // So, of all single-arg static methods:
  for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
    if (isFactoryMethod(am)) {
      // And must take one of expected arg types (or supertype)
      Class<?> actualArgType = am.getParameterClass(0);
      for (Class<?> expArgType : expArgTypes) {
        // And one that matches what we would pass in
        if (actualArgType.isAssignableFrom(expArgType)) {
          return am.getAnnotated();
        }
      }
    }
  }
  return null;
}

/**
 * Method that can be called to find if introspected class declares
 * a static "valueOf" factory method that returns an instance of
 * introspected type, given one of acceptable types.
 *
 * @param expArgTypes Types that the matching single argument factory
 *   method can take: will also accept super types of these types
 *   (ie. arg just has to be assignable from expArgType)
 */
public Method findFactoryMethod(Class<?>... expArgTypes)
{
  // So, of all single-arg static methods:
  for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
    if (isFactoryMethod(am)) {
      // And must take one of expected arg types (or supertype)
      Class<?> actualArgType = am.getParameterClass(0);
      for (Class<?> expArgType : expArgTypes) {
        // And one that matches what we would pass in
        if (actualArgType.isAssignableFrom(expArgType)) {
          return am.getAnnotated();
        }
      }
    }
  }
  return null;
}

/**
 * Method that can be called to find if introspected class declares
 * a static "valueOf" factory method that returns an instance of
 * introspected type, given one of acceptable types.
 *
 * @param expArgTypes Types that the matching single argument factory
 *   method can take: will also accept super types of these types
 *   (ie. arg just has to be assignable from expArgType)
 */
public Method findFactoryMethod(Class<?>... expArgTypes)
{
  // So, of all single-arg static methods:
  for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
    if (isFactoryMethod(am)) {
      // And must take one of expected arg types (or supertype)
      Class<?> actualArgType = am.getParameterClass(0);
      for (Class<?> expArgType : expArgTypes) {
        // And one that matches what we would pass in
        if (actualArgType.isAssignableFrom(expArgType)) {
          return am.getAnnotated();
        }
      }
    }
  }
  return null;
}

/**
 * Method that can be called to find if introspected class declares
 * a static "valueOf" factory method that returns an instance of
 * introspected type, given one of acceptable types.
 *
 * @param expArgTypes Types that the matching single argument factory
 *   method can take: will also accept super types of these types
 *   (ie. arg just has to be assignable from expArgType)
 */
public Method findFactoryMethod(Class<?>... expArgTypes)
{
  // So, of all single-arg static methods:
  for (AnnotatedMethod am : _classInfo.getStaticMethods()) {
    if (isFactoryMethod(am)) {
      // And must take one of expected arg types (or supertype)
      Class<?> actualArgType = am.getParameterClass(0);
      for (Class<?> expArgType : expArgTypes) {
        // And one that matches what we would pass in
        if (actualArgType.isAssignableFrom(expArgType)) {
          return am.getAnnotated();
        }
      }
    }
  }
  return null;
}