protected void verifyNonDup(AnnotatedWithParams newOne, int typeIndex, boolean explicit) {
    final int mask = (1 << typeIndex);
    _hasNonDefaultCreator = true;
    AnnotatedWithParams oldOne = _creators[typeIndex];
    // already had an explicitly marked one?
    if (oldOne != null) {
      boolean verify;

      if ((_explicitCreators & mask) != 0) { // already had explicitly annotated, leave as-is
        // but skip, if new one not annotated
        if (!explicit) {
          return;
        }
        // both explicit: verify
        verify = true;
      } else {
        // otherwise only verify if neither explicitly annotated.
        verify = !explicit;
      }

      // one more thing: ok to override in sub-class
      if (verify && (oldOne.getClass() == newOne.getClass())) {
        // [databind#667]: avoid one particular class of bogus problems
        Class<?> oldType = oldOne.getRawParameterType(0);
        Class<?> newType = newOne.getRawParameterType(0);

        if (oldType == newType) {
          throw new IllegalArgumentException(
              "Conflicting "
                  + TYPE_DESCS[typeIndex]
                  + " creators: already had explicitly marked "
                  + oldOne
                  + ", encountered "
                  + newOne);
        }
        // otherwise, which one to choose?
        if (newType.isAssignableFrom(oldType)) {
          // new type more generic, use old
          return;
        }
        // new type more specific, use it
      }
    }
    if (explicit) {
      _explicitCreators |= mask;
    }
    _creators[typeIndex] = _fixAccess(newOne);
  }
  /**
   * Method for getting ordered list of named Creator properties. Returns an empty list is none
   * found. If multiple Creator methods are defined, order between properties from different methods
   * is undefined; however, properties for each such Creator are ordered properly relative to each
   * other. For the usual case of just a single Creator, named properties are thus properly ordered.
   */
  public List<String> findCreatorPropertyNames() {
    List<String> names = null;

    for (int i = 0; i < 2; ++i) {
      List<? extends AnnotatedWithParams> l = (i == 0) ? getConstructors() : getFactoryMethods();
      for (AnnotatedWithParams creator : l) {
        int argCount = creator.getParameterCount();
        if (argCount < 1) continue;
        String name = _annotationIntrospector.findPropertyNameForParam(creator.getParameter(0));
        if (name == null) continue;
        if (names == null) {
          names = new ArrayList<String>();
        }
        names.add(name);
        for (int p = 1; p < argCount; ++p) {
          names.add(_annotationIntrospector.findPropertyNameForParam(creator.getParameter(p)));
        }
      }
    }
    if (names == null) {
      return Collections.emptyList();
    }
    return names;
  }