@Override
    public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
        throws JsonMappingException
    {
        JsonArrayFormatVisitor arrayVisitor = visitor.expectArrayFormat(typeHint);
        if (arrayVisitor != null) {
            JavaType contentType = _elementType;

            // [databind#1793]: Was getting `null` for `typeHint`. But why would we even use it...
/*
            TypeFactory tf = visitor.getProvider().getTypeFactory();
            contentType = tf.moreSpecificType(_elementType, typeHint.getContentType());
            if (contentType == null) {
                visitor.getProvider().reportBadDefinition(_elementType,
                        "Could not resolve type: "+_elementType);
            }
*/
            JsonSerializer<?> valueSer = _elementSerializer;
            if (valueSer == null) {
                valueSer = visitor.getProvider().findValueSerializer(contentType, _property);
            }
            arrayVisitor.itemsFormat(valueSer, contentType);
        }
    }
 

@Override
public void depositSchemaProperty(final JsonObjectFormatVisitor visitor,
        SerializerProvider provider) throws JsonMappingException
{
    JsonSerializer<Object> ser = provider
            .findValueSerializer(this.getType(), this)
            .unwrappingSerializer(_nameTransformer);

    if (ser.isUnwrappingSerializer()) {
        ser.acceptJsonFormatVisitor(new JsonFormatVisitorWrapper.Base(provider) {
            // an unwrapping serializer will always expect ObjectFormat,
            // hence, the other cases do not have to be implemented
            @Override
            public JsonObjectFormatVisitor expectObjectFormat(JavaType type)
                    throws JsonMappingException {
                return visitor;
            }
        }, this.getType());
    } else {
        super.depositSchemaProperty(visitor, provider);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    if (visitor != null) {
        JsonObjectFormatVisitor objectVisitor = visitor.expectObjectFormat(typeHint);
        if (objectVisitor != null) {
            if (_endpointSerializer != null) {
                JavaType endpointType = _rangeType.containedType(0);
                JavaType btType = visitor.getProvider().constructType(BoundType.class);
                // should probably keep track of `property`...
                JsonSerializer<?> btSer = visitor.getProvider()
                        .findContentValueSerializer(btType, null);
                objectVisitor.property(_fieldNames.lowerEndpoint, _endpointSerializer, endpointType);
                objectVisitor.property(_fieldNames.lowerBoundType, btSer, btType);
                objectVisitor.property(_fieldNames.upperEndpoint, _endpointSerializer, endpointType);
                objectVisitor.property(_fieldNames.upperBoundType, btSer, btType);
            }
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(final JsonFormatVisitorWrapper wrapper, final JavaType hint)
        throws JsonMappingException {

    @Nullable final JsonObjectFormatVisitor visitor = wrapper.expectObjectFormat(hint);

    if (visitor == null) {
        return;
    }

    final SerializerProvider provider = wrapper.getProvider();

    visitor.property(names.getAmount(),
            provider.findValueSerializer(writer.getType()),
            provider.constructType(writer.getType()));

    visitor.property(names.getCurrency(),
            provider.findValueSerializer(CurrencyUnit.class),
            provider.constructType(CurrencyUnit.class));

    visitor.optionalProperty(names.getFormatted(),
            provider.findValueSerializer(String.class),
            provider.constructType(String.class));
}
 

/**
 * Default implementation simply calls {@link JsonFormatVisitorWrapper#expectAnyFormat(JavaType)}.
 * 
 * @since 2.1
 */
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType type)
    throws JsonMappingException
{
    visitor.expectAnyFormat(type);
}
 

/**
 * The method to be called by {@link ObjectMapper} and {@link ObjectWriter}
 * to to expose the format of the given to to the given visitor
 *
 * @param javaType The type for which to generate format
 * @param visitor the visitor to accept the format
 */
public void acceptJsonFormatVisitor(JavaType javaType, JsonFormatVisitorWrapper visitor)
    throws JsonMappingException
{
    if (javaType == null) {
        throw new IllegalArgumentException("A class must be provided");
    }
    /* no need for embedded type information for JSON schema generation (all
     * type information it needs is accessible via "untyped" serializer)
     */
    visitor.setProvider(this);
    findValueSerializer(javaType, null).acceptJsonFormatVisitor(visitor, javaType);
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
    if (_isInt) {
        visitIntFormat(visitor, typeHint, JsonParser.NumberType.BIG_INTEGER);
    } else {
        Class<?> h = handledType();
        if (h == BigDecimal.class) {
            visitFloatFormat(visitor, typeHint, JsonParser.NumberType.BIG_DECIMAL);
        } else {
            // otherwise bit unclear what to call... but let's try:
            /*JsonNumberFormatVisitor v2 =*/ visitor.expectNumberFormat(typeHint);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    // Not 100% sure what we should say here: type is basically not known.
    // This seems like closest approximation
    visitor.expectAnyFormat(typeHint);
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    /* 27-Apr-2015, tatu: First things first; for JSON Schema introspection,
     *    Enum types that use `@JsonValue` are special (but NOT necessarily
     *    anything else that RETURNS an enum!)
     *    So we will need to add special
     *    handling here (see https://github.com/FasterXML/jackson-module-jsonSchema/issues/57
     *    for details).
     *    
     *    Note that meaning of JsonValue, then, is very different for Enums. Sigh.
     */
    final JavaType type = _accessor.getType();
    Class<?> declaring = _accessor.getDeclaringClass();
    if ((declaring != null) && declaring.isEnum()) {
        if (_acceptJsonFormatVisitorForEnum(visitor, typeHint, declaring)) {
            return;
        }
    }
    JsonSerializer<Object> ser = _valueSerializer;
    if (ser == null) {
        ser = visitor.getProvider().findTypedValueSerializer(type, false, _property);
        if (ser == null) { // can this ever occur?
            visitor.expectAnyFormat(typeHint);
            return;
        }
    }
    ser.acceptJsonFormatVisitor(visitor, type);
}
 

/**
 * Overridable helper method used for special case handling of schema information for
 * Enums.
 * 
 * @return True if method handled callbacks; false if not; in latter case caller will
 *   send default callbacks
 *
 * @since 2.6
 */
protected boolean _acceptJsonFormatVisitorForEnum(JsonFormatVisitorWrapper visitor,
        JavaType typeHint, Class<?> enumType)
    throws JsonMappingException
{
    // Copied from EnumSerializer#acceptJsonFormatVisitor
    JsonStringFormatVisitor stringVisitor = visitor.expectStringFormat(typeHint);
    if (stringVisitor != null) {
        Set<String> enums = new LinkedHashSet<String>();
        for (Object en : enumType.getEnumConstants()) {
            try {
                // 21-Apr-2016, tatu: This is convoluted to the max, but essentially we
                //   call `@JsonValue`-annotated accessor method on all Enum members,
                //   so it all "works out". To some degree.
                enums.add(String.valueOf(_accessor.getValue(en)));
            } catch (Exception e) {
                Throwable t = e;
                while (t instanceof InvocationTargetException && t.getCause() != null) {
                    t = t.getCause();
                }
                ClassUtil.throwIfError(t);
                throw JsonMappingException.wrapWithPath(t, en, _accessor.getName() + "()");
            }
        }
        stringVisitor.enumTypes(enums);
    }
    return true;
}
 

@Override // since 2.9
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    // 31-Mar-2017, tatu: Use same type as `ByteArraySerializer`: not optimal but has to do
    JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
    if (v2 != null) {
        v2.itemsFormat(JsonFormatTypes.INTEGER);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    JsonMapFormatVisitor v2 = visitor.expectMapFormat(typeHint);        
    if (v2 != null) {
        v2.keyFormat(_keySerializer, _keyType);
        JsonSerializer<?> valueSer = _valueSerializer;
        if (valueSer == null) {
            valueSer = _findAndAddDynamic(_dynamicValueSerializers,
                        _valueType, visitor.getProvider());
        }
        v2.valueFormat(valueSer, _valueType);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    JsonSerializer<?> ser = _valueSerializer;
    if (ser == null) {
        ser = _findSerializer(visitor.getProvider(), _referredType, _property);
        if (_unwrapper != null) {
            ser = ser.unwrappingSerializer(_unwrapper);
        }
    }
    ser.acceptJsonFormatVisitor(visitor, _referredType);
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    // 13-Sep-2013, tatu: Let's assume it's usually a String, right?
    visitStringFormat(visitor, typeHint);
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    SerializerProvider serializers = visitor.getProvider();
    if (_serializeAsIndex(serializers)) {
        visitIntFormat(visitor, typeHint, JsonParser.NumberType.INT);
        return;
    }
    JsonStringFormatVisitor stringVisitor = visitor.expectStringFormat(typeHint);
    if (stringVisitor != null) {
        Set<String> enums = new LinkedHashSet<String>();
        
        // Use toString()?
        if ((serializers != null) && 
                serializers.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING)) {
            for (Enum<?> e : _values.enums()) {
                enums.add(e.toString());
            }
        } else {
            // No, serialize using name() or explicit overrides
            for (SerializableString value : _values.values()) {
                enums.add(value.getValue());
            }
        }
        stringVisitor.enumTypes(enums);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    //deposit your output format 
    if (visitor == null) {
        return;
    }
    JsonObjectFormatVisitor objectVisitor = visitor.expectObjectFormat(typeHint);
    if (objectVisitor == null) {
        return;
    }
    final SerializerProvider provider = visitor.getProvider();
    if (_propertyFilterId != null) {
        PropertyFilter filter = findPropertyFilter(visitor.getProvider(),
                _propertyFilterId, null);
        for (int i = 0, end = _props.length; i < end; ++i) {
            filter.depositSchemaProperty(_props[i], objectVisitor, provider);
        }
    } else {
        Class<?> view = ((_filteredProps == null) || (provider == null))
                ? null : provider.getActiveView();
        final BeanPropertyWriter[] props;
        if (view != null) {
            props = _filteredProps;
        } else {
            props = _props;
        }

        for (int i = 0, end = props.length; i < end; ++i) {
            BeanPropertyWriter prop = props[i];
            if (prop != null) { // may be filtered out unconditionally
                prop.depositSchemaProperty(objectVisitor, provider);
            }
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    JsonSerializer<?> valueSer = _elementSerializer;
    if (valueSer == null) {
        // 19-Oct-2016, tatu: Apparently we get null for untyped/raw `EnumSet`s... not 100%
        //   sure what'd be the clean way but let's try this for now:
        if (_elementType != null) {
            valueSer = visitor.getProvider().findValueSerializer(_elementType, _property);
        }
    }
    visitArrayFormat(visitor, typeHint, valueSer, _elementType);
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
        JavaType typeHint) throws JsonMappingException
{
    if (_isInt) {
        visitIntFormat(visitor, typeHint, _numberType);
    } else {
        visitFloatFormat(visitor, typeHint, _numberType);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    // 14-Mar-2016, tatu: while logically (and within JVM) binary, gets encoded as Base64 String,
    // let's try to indicate it is array of Bytes... difficult, thanks to JSON Schema's
    // lackluster listing of types
    //
    // TODO: for 2.8, make work either as String/base64, or array of numbers,
    //   with a qualifier that can be used to determine it's byte[]
    JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
    if (v2 != null) {
        v2.itemsFormat(JsonFormatTypes.INTEGER);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    /* 03-Sep-2012, tatu: Not sure if this can be made to really work
     *    properly... but for now, try this:
     */
    // 02-Apr-2015, tatu: For dynamic case, very little we can do
    if (_delegateSerializer != null) {
        _delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    JsonMapFormatVisitor v2 = (visitor == null) ? null : visitor.expectMapFormat(typeHint);        
    if (v2 != null) {
        v2.keyFormat(_keySerializer, _type.getKeyType());
        JsonSerializer<?> valueSer = _valueSerializer;
        final JavaType vt = _type.getContentType();
        final SerializerProvider prov = visitor.getProvider();
        if (valueSer == null) {
            valueSer = _findAndAddDynamic(prov, vt);
        }
        final JsonSerializer<?> valueSer2 = valueSer;
        v2.valueFormat(new JsonFormatVisitable() {
            final JavaType arrayType = prov.getTypeFactory().constructArrayType(vt);
            @Override
            public void acceptJsonFormatVisitor(
                    JsonFormatVisitorWrapper v3, JavaType hint3)
                throws JsonMappingException
            {
                JsonArrayFormatVisitor v4 = v3.expectArrayFormat(arrayType);
                if (v4 != null) {
                    v4.itemsFormat(valueSer2, vt);
                }
            }
        }, vt);
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
        throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.INTEGER);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
        throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.INTEGER);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
        throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.INTEGER);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
        throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.INTEGER);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.NUMBER);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
    throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.NUMBER);
        }
    }
}
 

@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
        throws JsonMappingException
{
    if (visitor != null) {
        JsonArrayFormatVisitor v2 = visitor.expectArrayFormat(typeHint);
        if (v2 != null) {
            v2.itemsFormat(JsonFormatTypes.BOOLEAN);
        }
    }
}
 

@Override
protected void _acceptTimestampVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
    SerializerProvider provider = visitor.getProvider();
    boolean useTimestamp = (provider != null) && useTimestamp(provider);
    if (useTimestamp) {
        super._acceptTimestampVisitor(visitor, typeHint);
    } else {
        JsonStringFormatVisitor v2 = visitor.expectStringFormat(typeHint);
        if (v2 != null) {
            v2.format(JsonValueFormat.DATE_TIME);
        }
    }
}
 

@Override
protected void _acceptTimestampVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
    JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint);
    if (v2 != null) {
        v2.numberType(JsonParser.NumberType.LONG);
        SerializerProvider provider = visitor.getProvider();
        if ((provider != null) && useNanoseconds(provider)) {
            // big number, no more specific qualifier to use...
        } else { // otherwise good old Unix timestamp, in milliseconds
            v2.format(JsonValueFormat.UTC_MILLISEC);
        }
    }
}