protected void _reportIncompatibleRootType(Object value, JavaType rootType) throws IOException {
   // One special case: allow primitive/wrapper type coercion
   if (rootType.isPrimitive()) {
     Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass());
     // If it's just difference between wrapper, primitive, let it slide
     if (wrapperType.isAssignableFrom(value.getClass())) {
       return;
     }
   }
   throw JsonMappingException.from(
       this,
       "Incompatible types: declared root type ("
           + rootType
           + ") vs "
           + value.getClass().getName());
 }
 protected void _reportIncompatibleRootType(Object value, JavaType rootType) throws IOException {
   /* 07-Jan-2010, tatu: As per [JACKSON-456] better handle distinction between wrapper types,
    *    primitives
    */
   if (rootType.isPrimitive()) {
     Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass());
     // If it's just difference between wrapper, primitive, let it slide
     if (wrapperType.isAssignableFrom(value.getClass())) {
       return;
     }
   }
   throw JsonMappingException.from(
       this,
       "Incompatible types: declared root type ("
           + rootType
           + ") vs "
           + value.getClass().getName());
 }
 /**
  * Method variant used when we do NOT want contextualization to happen; it will need to be handled
  * at a later point, but caller wants to be able to do that as needed; sometimes to avoid infinite
  * loops
  *
  * @since 2.5
  */
 public JsonSerializer<Object> findValueSerializer(JavaType valueType)
     throws JsonMappingException {
   // (see comments from above method)
   JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType);
   if (ser == null) {
     ser = _serializerCache.untypedValueSerializer(valueType);
     if (ser == null) {
       ser = _createAndCacheUntypedSerializer(valueType);
       if (ser == null) {
         ser = getUnknownTypeSerializer(valueType.getRawClass());
         if (CACHE_UNKNOWN_MAPPINGS) {
           _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this);
         }
       }
     }
   }
   return ser;
 }
 /**
  * Similar to {@link #findValueSerializer(JavaType, BeanProperty)}, but used when finding
  * "primary" property value serializer (one directly handling value of the property). Difference
  * has to do with contextual resolution, and method(s) called: this method should only be called
  * when caller is certain that this is the primary property value serializer.
  *
  * @param property Property that is being handled; will never be null, and its type has to match
  *     <code>valueType</code> parameter.
  * @since 2.3
  */
 @SuppressWarnings("unchecked")
 public JsonSerializer<Object> findPrimaryPropertySerializer(
     JavaType valueType, BeanProperty property) throws JsonMappingException {
   JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType);
   if (ser == null) {
     ser = _serializerCache.untypedValueSerializer(valueType);
     if (ser == null) {
       ser = _createAndCacheUntypedSerializer(valueType);
       if (ser == null) {
         ser = getUnknownTypeSerializer(valueType.getRawClass());
         // Should this be added to lookups?
         if (CACHE_UNKNOWN_MAPPINGS) {
           _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this);
         }
         return ser;
       }
     }
   }
   return (JsonSerializer<Object>) handlePrimaryContextualization(ser, property);
 }
 /**
  * Similar to {@link #findValueSerializer(Class,BeanProperty)}, but takes full generics-aware type
  * instead of raw class. This is necessary for accurate handling of external type information, to
  * handle polymorphic types.
  *
  * @param property When creating secondary serializers, property for which serializer is needed:
  *     annotations of the property (or bean that contains it) may be checked to create contextual
  *     serializers.
  */
 @SuppressWarnings("unchecked")
 public JsonSerializer<Object> findValueSerializer(JavaType valueType, BeanProperty property)
     throws JsonMappingException {
   // (see comments from above method)
   JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType);
   if (ser == null) {
     ser = _serializerCache.untypedValueSerializer(valueType);
     if (ser == null) {
       ser = _createAndCacheUntypedSerializer(valueType);
       if (ser == null) {
         ser = getUnknownTypeSerializer(valueType.getRawClass());
         if (CACHE_UNKNOWN_MAPPINGS) {
           _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this);
         }
         return ser;
       }
     }
   }
   return (JsonSerializer<Object>) handleSecondaryContextualization(ser, property);
 }