import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public ObjBase makeValue(ObjectId id, DBObject rawData, Class<? extends ObjBase> c){

        if (Modifier.isAbstract(c.getModifiers()) || Modifier.isInterface(c.getModifiers())) {
            //extract declared schema from result, use that class
            Object schemaId = rawData.get(ReservedFieldNames.SCHEMA);
            try {
                c = (Class<ObjBase>) ClassUtil.findClass(schemaId.toString());
            } catch (ClassNotFoundException ex) {
                log.warn("Could not find fallback schema {}", schemaId);
                return null;
            }
        }
        
        ObjBase value = makeStub(id, c, rawData);
        // update stub with the rest of the data, 
        if (value != null && !(value instanceof Swappable)) 
            try {
                unmarshaller.unmarshall(Bson.createDocument(rawData), value, this);
            } catch (MarshallingException me){
                log.warn(me.getMessage(), me);
            }
        
        return value;
    }
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
@Override
public JavaType typeFromId(String id) {
    try{
        return super.typeFromId(id);
    } catch (IllegalArgumentException iae){
        try {
            //try the widening type construction instead
            Class<?> cls =  ClassUtil.findClass(id);
            if (cls.isAssignableFrom(_baseType.getRawClass()) || _baseType.getRawClass().equals(JSONFilter.class)) return _baseType;
            //TODO: make this message not suck
            else throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): ");
        } catch (ClassNotFoundException cnfe){
            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found");
        } 
        catch (Exception e){
            //could neither narrow or widen that type combination
            throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e);
        } 
        
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
protected BeanPropertyWriter _constructWriter(SerializerProvider paramSerializerProvider, BeanPropertyDefinition paramBeanPropertyDefinition, TypeBindings paramTypeBindings, PropertyBuilder paramPropertyBuilder, boolean paramBoolean, AnnotatedMember paramAnnotatedMember)
{
  String str = paramBeanPropertyDefinition.getName();
  if (paramSerializerProvider.canOverrideAccessModifiers())
    paramAnnotatedMember.fixAccess();
  JavaType localJavaType = paramAnnotatedMember.getType(paramTypeBindings);
  BeanProperty.Std localStd = new BeanProperty.Std(str, localJavaType, paramBeanPropertyDefinition.getWrapperName(), paramPropertyBuilder.getClassAnnotations(), paramAnnotatedMember, paramBeanPropertyDefinition.isRequired());
  JsonSerializer localJsonSerializer1 = findSerializerFromAnnotation(paramSerializerProvider, paramAnnotatedMember);
  JsonSerializer localJsonSerializer2 = localJsonSerializer1;
  if ((localJsonSerializer1 instanceof ResolvableSerializer))
    ((ResolvableSerializer)localJsonSerializer2).resolve(paramSerializerProvider);
  if ((localJsonSerializer2 instanceof ContextualSerializer))
    localJsonSerializer2 = ((ContextualSerializer)localJsonSerializer2).createContextual(paramSerializerProvider, localStd);
  boolean bool = ClassUtil.isCollectionMapOrArray(localJavaType.getRawClass());
  TypeSerializer localTypeSerializer1 = null;
  if (bool)
    localTypeSerializer1 = findPropertyContentTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  TypeSerializer localTypeSerializer2 = findPropertyTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  return paramPropertyBuilder.buildWriter(paramBeanPropertyDefinition, localJavaType, localJsonSerializer2, localTypeSerializer2, localTypeSerializer1, paramAnnotatedMember, paramBoolean);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
private PropertyNamingStrategy _findNamingStrategy()
{
  Object localObject1;
  if (this._annotationIntrospector == null)
    localObject1 = null;
  else
    localObject1 = this._annotationIntrospector.findNamingStrategy(this._classDef);
  Object localObject2 = localObject1;
  if (localObject1 == null)
    return this._config.getPropertyNamingStrategy();
  if ((localObject2 instanceof PropertyNamingStrategy))
    return (PropertyNamingStrategy)localObject2;
  if (!(localObject2 instanceof Class))
    throw new IllegalStateException("AnnotationIntrospector returned PropertyNamingStrategy definition of type " + localObject2.getClass().getName() + "; expected type PropertyNamingStrategy or Class<PropertyNamingStrategy> instead");
  Class localClass = (Class)localObject2;
  if (!PropertyNamingStrategy.class.isAssignableFrom(localClass))
    throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<PropertyNamingStrategy>");
  HandlerInstantiator localHandlerInstantiator = this._config.getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    PropertyNamingStrategy localPropertyNamingStrategy = localHandlerInstantiator.namingStrategyInstance(this._config, this._classDef, localClass);
    if (localPropertyNamingStrategy != null)
      return localPropertyNamingStrategy;
  }
  return (PropertyNamingStrategy)ClassUtil.createInstance(localClass, this._config.canOverrideAccessModifiers());
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
protected final void _addMethodMixIns(Class<?> paramClass1, AnnotatedMethodMap paramAnnotatedMethodMap1, Class<?> paramClass2, AnnotatedMethodMap paramAnnotatedMethodMap2)
{
  ArrayList localArrayList = new ArrayList();
  localArrayList.add(paramClass2);
  ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList);
  Iterator localIterator = localArrayList.iterator();
  while (localIterator.hasNext())
    for (Method localMethod : ((Class)localIterator.next()).getDeclaredMethods())
      if (_isIncludableMemberMethod(localMethod))
      {
        AnnotatedMethod localAnnotatedMethod = paramAnnotatedMethodMap1.find(localMethod);
        if (localAnnotatedMethod != null)
          _addMixUnders(localMethod, localAnnotatedMethod);
        else
          paramAnnotatedMethodMap2.add(_constructMethod(localMethod));
      }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public ValueInstantiator _valueInstantiatorInstance(DeserializationConfig paramDeserializationConfig, Annotated paramAnnotated, Object paramObject)
{
  if (paramObject == null)
    return null;
  if ((paramObject instanceof ValueInstantiator))
    return (ValueInstantiator)paramObject;
  if (!(paramObject instanceof Class))
    throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type " + paramObject.getClass().getName() + "; expected type KeyDeserializer or Class<KeyDeserializer> instead");
  Class localClass = (Class)paramObject;
  if (localClass == NoClass.class)
    return null;
  if (!ValueInstantiator.class.isAssignableFrom(localClass))
    throw new IllegalStateException("AnnotationIntrospector returned Class " + localClass.getName() + "; expected Class<ValueInstantiator>");
  HandlerInstantiator localHandlerInstantiator = paramDeserializationConfig.getHandlerInstantiator();
  if (localHandlerInstantiator != null)
  {
    ValueInstantiator localValueInstantiator = localHandlerInstantiator.valueInstantiatorInstance(paramDeserializationConfig, paramAnnotated, localClass);
    if (localValueInstantiator != null)
      return localValueInstantiator;
  }
  return (ValueInstantiator)ClassUtil.createInstance(localClass, paramDeserializationConfig.canOverrideAccessModifiers());
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public Class<?> deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext)
{
  JsonToken localJsonToken = paramJsonParser.getCurrentToken();
  if (localJsonToken == JsonToken.VALUE_STRING)
  {
    String str = paramJsonParser.getText().trim();
    try
    {
      Class localClass = paramDeserializationContext.findClass(str);
      return localClass;
    }
    catch (Exception localException)
    {
      throw paramDeserializationContext.instantiationException(this._valueClass, ClassUtil.getRootCause(localException));
    }
  }
  throw paramDeserializationContext.mappingException(this._valueClass, localJsonToken);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig paramDeserializationConfig, Class<?> paramClass, AnnotatedMethod paramAnnotatedMethod)
{
  Class localClass = paramAnnotatedMethod.getRawParameterType(0);
  Object localObject;
  if (localClass == String.class)
    localObject = null;
  else if ((localClass == Integer.TYPE) || (localClass == Integer.class))
    localObject = Integer.class;
  else if ((localClass == Long.TYPE) || (localClass == Long.class))
    localObject = Long.class;
  else
    throw new IllegalArgumentException("Parameter #0 type for factory method (" + paramAnnotatedMethod + ") not suitable, must be java.lang.String or int/Integer/long/Long");
  if (paramDeserializationConfig.canOverrideAccessModifiers())
    ClassUtil.checkAndFixAccess(paramAnnotatedMethod.getMember());
  return new FactoryBasedDeserializer(paramClass, paramAnnotatedMethod, (Class)localObject);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public Object deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext)
{
  Object localObject1;
  if (this._inputType == null)
    localObject1 = paramJsonParser.getText();
  else if (this._inputType == Integer.class)
    localObject1 = Integer.valueOf(paramJsonParser.getValueAsInt());
  else if (this._inputType == Long.class)
    localObject1 = Long.valueOf(paramJsonParser.getValueAsLong());
  else
    throw paramDeserializationContext.mappingException(this._enumClass);
  try
  {
    Object localObject2 = this._factory.invoke(this._enumClass, new Object[] { localObject1 });
    return localObject2;
  }
  catch (Exception localException)
  {
    ClassUtil.unwrapAndThrowAsIAE(localException);
  }
  return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public static KeyDeserializer findStringBasedKeyDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType)
{
  BeanDescription localBeanDescription = paramDeserializationConfig.introspect(paramJavaType);
  Constructor localConstructor = localBeanDescription.findSingleArgConstructor(new Class[] { String.class });
  if (localConstructor != null)
  {
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localConstructor);
    return new StdKeyDeserializer.StringCtorKeyDeserializer(localConstructor);
  }
  Method localMethod = localBeanDescription.findFactoryMethod(new Class[] { String.class });
  if (localMethod != null)
  {
    if (paramDeserializationConfig.canOverrideAccessModifiers())
      ClassUtil.checkAndFixAccess(localMethod);
    return new StdKeyDeserializer.StringFactoryKeyDeserializer(localMethod);
  }
  return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
public final Object _parse(String paramString, DeserializationContext paramDeserializationContext)
{
  if (this._factory != null)
    try
    {
      Object localObject = this._factory.call1(paramString);
      return localObject;
    }
    catch (Exception localException)
    {
      ClassUtil.unwrapAndThrowAsIAE(localException);
    }
  Enum localEnum = this._resolver.findEnum(paramString);
  if ((localEnum == null) && (!paramDeserializationContext.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)))
    throw paramDeserializationContext.weirdKeyException(this._keyClass, paramString, "not one of values for Enum class");
  return localEnum;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty)
{
  JsonDeserializer localJsonDeserializer = paramSettableBeanProperty.getValueDeserializer();
  if (((localJsonDeserializer instanceof BeanDeserializerBase)) && (!((BeanDeserializerBase)localJsonDeserializer).getValueInstantiator().canCreateUsingDefault()))
  {
    Class localClass1 = paramSettableBeanProperty.getType().getRawClass();
    Class localClass2 = ClassUtil.getOuterClass(localClass1);
    if ((localClass2 != null) && (localClass2 == this._beanType.getRawClass()))
      for (Constructor localConstructor : localClass1.getConstructors())
      {
        Class[] arrayOfClass = localConstructor.getParameterTypes();
        if ((arrayOfClass.length == 1) && (arrayOfClass[0] == localClass2))
        {
          if (paramDeserializationContext.getConfig().canOverrideAccessModifiers())
            ClassUtil.checkAndFixAccess(localConstructor);
          return new InnerClassProperty(paramSettableBeanProperty, localConstructor);
        }
      }
  }
  return paramSettableBeanProperty;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
@Override
public JavaType typeFromId(String id)
{
/* 30-Jan-2010, tatu: Most ids are basic class names; so let's first
 *    check if any generics info is added; and only then ask factory
 *    to do translation when necessary
 */
    if (id.indexOf('<') > 0) {
        JavaType t = typeFactory.constructFromCanonical(id);
        // note: may want to try combining with specialization (esp for EnumMap)?
        return t;
    }
    try {
        Class<?> cls =  ClassUtil.findClass(id);
        return typeFactory.constructSpecializedType(baseType, cls);
    } catch (ClassNotFoundException ignored) {
        throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): no such class found");
    } catch (Exception e) {
        throw new IllegalArgumentException("Invalid type id '"+id+"' (for id type 'Id.class'): "+e.getMessage(), e);
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
@Override
public ObjectIdGenerator<?> objectIdGeneratorInstance(Annotated annotated,
        ObjectIdInfo objectIdInfo)
    throws JsonMappingException
{
    Class<?> implClass = objectIdInfo.getGeneratorType();
    HandlerInstantiator hi = _config.getHandlerInstantiator();
    ObjectIdGenerator<?> gen;

    if (hi != null) {
        gen =  hi.objectIdGeneratorInstance(_config, annotated, implClass);
    } else {
        gen = (ObjectIdGenerator<?>) ClassUtil.createInstance(implClass,
                _config.canOverrideAccessModifiers());
    }
    return gen.forScope(objectIdInfo.getScope());
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
/**
 * Method called to see if one of primary per-class annotations
 * (or related, like implementing of {@link JsonSerializable})
 * determines the serializer to use.
 *<p>
 * Currently handles things like:
 *<ul>
 * <li>If type implements {@link JsonSerializable}, use that
 *  </li>
 * <li>If type has {@link com.fasterxml.jackson.annotation.JsonValue} annotation (or equivalent), build serializer
 *    based on that property
 *  </li>
 *</ul>
 *
 * @since 2.0
 */
protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov, 
        JavaType type, BeanDescription beanDesc)
    throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    // First: JsonSerializable?
    if (JsonSerializable.class.isAssignableFrom(raw)) {
        return SerializableSerializer.instance;
    }
    // Second: @JsonValue for any type
    AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod();
    if (valueMethod != null) {
        Method m = valueMethod.getAnnotated();
        if (prov.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(m);
        }
        JsonSerializer<Object> ser = findSerializerFromAnnotation(prov, valueMethod);
        return new JsonValueSerializer(m, ser);
    }
    // No well-known annotations...
    return null;
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask,
                               Class<?> mixin)
{
    if (mixin == null) {
        return;
    }
    // Ok, first: annotations from mix-in class itself:
    _addAnnotationsIfNotPresent(annotations, mixin.getDeclaredAnnotations());

    /* And then from its supertypes, if any. But note that we will
     * only consider super-types up until reaching the masked
     * class (if found); this because often mix-in class
     * is a sub-class (for convenience reasons). And if so, we
     * absolutely must NOT include super types of masked class,
     * as that would inverse precedence of annotations.
     */
    for (Class<?> parent : ClassUtil.findSuperTypes(mixin, toMask)) {
        _addAnnotationsIfNotPresent(annotations, parent.getDeclaredAnnotations());
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
/**
 * Method called to add field mix-ins from given mix-in class (and its fields)
 * into already collected actual fields (from introspected classes and their
 * super-classes)
 */
protected void _addFieldMixIns(Class<?> targetClass, Class<?> mixInCls,
        Map<String,AnnotatedField> fields)
{
    List<Class<?>> parents = new ArrayList<Class<?>>();
    parents.add(mixInCls);
    ClassUtil.findSuperTypes(mixInCls, targetClass, parents);
    for (Class<?> mixin : parents) {
        for (Field mixinField : mixin.getDeclaredFields()) {
            // there are some dummy things (static, synthetic); better ignore
            if (!_isIncludableField(mixinField)) {
                continue;
            }
            String name = mixinField.getName();
            // anything to mask? (if not, quietly ignore)
            AnnotatedField maskedField = fields.get(name);
            if (maskedField != null) {
                _addOrOverrideAnnotations(maskedField, mixinField.getDeclaredAnnotations());
            }
        }
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
protected EnumResolver<?> constructEnumResolver(Class<?> enumClass,
        DeserializationConfig config, AnnotatedMethod jsonValueMethod)
{
    if (jsonValueMethod != null) {
        Method accessor = jsonValueMethod.getAnnotated();
        if (config.canOverrideAccessModifiers()) {
            ClassUtil.checkAndFixAccess(accessor);
        }
        return EnumResolver.constructUnsafeUsingMethod(enumClass, accessor);
    }
    // [JACKSON-212]: may need to use Enum.toString()
    if (config.isEnabled(DeserializationFeature.READ_ENUMS_USING_TO_STRING)) {
        return EnumResolver.constructUnsafeUsingToString(enumClass);
    }
    return EnumResolver.constructUnsafe(enumClass, config.getAnnotationIntrospector());
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
@Override
public Class<?> deserialize(JsonParser jp, DeserializationContext ctxt)
    throws IOException, JsonProcessingException
{
    JsonToken curr = jp.getCurrentToken();
    // Currently will only accept if given simple class name
    if (curr == JsonToken.VALUE_STRING) {
        String className = jp.getText().trim();
        try {
            return ctxt.findClass(className);
        } catch (Exception e) {
            throw ctxt.instantiationException(_valueClass, ClassUtil.getRootCause(e));
        }
    }
    throw ctxt.mappingException(_valueClass, curr);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入依赖的package包/类
/**
 * Factory method used when Enum instances are to be deserialized
 * using a creator (static factory method)
 * 
 * @return Deserializer based on given factory method, if type was suitable;
 *  null if type can not be used
 */
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config,
        Class<?> enumClass, AnnotatedMethod factory)
{
    
    // note: caller has verified there's just one arg; but we must verify its type
    Class<?> paramClass = factory.getRawParameterType(0);
    if (paramClass == String.class) {
        paramClass = null;
    } else  if (paramClass == Integer.TYPE || paramClass == Integer.class) {
        paramClass = Integer.class;
    } else  if (paramClass == Long.TYPE || paramClass == Long.class) {
        paramClass = Long.class;
    } else {
        throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory
                +") not suitable, must be java.lang.String or int/Integer/long/Long");
    }
    if (config.canOverrideAccessModifiers()) {
        ClassUtil.checkAndFixAccess(factory.getMember());
    }
    return new FactoryBasedDeserializer(enumClass, factory, paramClass);
}