@Override
public void serializeWithType(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    // [databind#631]: Assign current value, to be accessible by custom serializers
    gen.setCurrentValue(value);
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen,
            typeSer.typeId(value, JsonToken.START_OBJECT));
    if (!value.isEmpty()) {
        if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
            value = _orderEntries(value, gen, provider);
        }
        PropertyFilter pf;
        if ((_filterId != null) && (pf = findPropertyFilter(provider, _filterId, value)) != null) {
            serializeFilteredFields(value, gen, provider, pf, _suppressableValue);
        } else if ((_suppressableValue != null) || _suppressNulls) {
            serializeOptionalFields(value, gen, provider, _suppressableValue);
        } else if (_valueSerializer != null) {
            serializeFieldsUsing(value, gen, provider, _valueSerializer);
        } else {
            serializeFields(value, gen, provider);
        }
    }
    typeSer.writeTypeSuffix(gen, typeIdDef);
}
 

@Override
public void serializeWithType(Object bean, JsonGenerator gen,
        SerializerProvider provider, TypeSerializer typeSer)
    throws IOException
{
    if (_objectIdWriter != null) {
        gen.setCurrentValue(bean); // [databind#631]
        _serializeWithObjectId(bean, gen, provider, typeSer);
        return;
    }

    gen.setCurrentValue(bean); // [databind#631]
    WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_OBJECT);
    typeSer.writeTypePrefix(gen, typeIdDef);
    if (_propertyFilterId != null) {
        serializeFieldsFiltered(bean, gen, provider);
    } else {
        serializeFields(bean, gen, provider);
    }
    typeSer.writeTypeSuffix(gen, typeIdDef);
}
 

protected  void _serializeObjectId(Object bean, JsonGenerator g,
        SerializerProvider provider,
        TypeSerializer typeSer, WritableObjectId objectId) throws IOException
{
    final ObjectIdWriter w = _objectIdWriter;
    WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_OBJECT);

    typeSer.writeTypePrefix(g, typeIdDef);
    objectId.writeAsField(g, provider, w);
    if (_propertyFilterId != null) {
        serializeFieldsFiltered(bean, g, provider);
    } else {
        serializeFields(bean, g, provider);
    }
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(byte[] value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    // most likely scalar
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.VALUE_EMBEDDED_OBJECT));
    g.writeBinary(provider.getConfig().getBase64Variant(),
            value, 0, value.length);
    typeSer.writeTypeSuffix(g, typeIdDef);

    /* OLD impl
    typeSer.writeTypePrefixForScalar(value, g);
    g.writeBinary(provider.getConfig().getBase64Variant(),
            value, 0, value.length);
    typeSer.writeTypeSuffixForScalar(value, g);
    */
}
 

@Override
public void serializeWithType(char[] value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    // [JACKSON-289] allows serializing as 'sparse' char array too:
    final boolean asArray = provider.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS);
    WritableTypeId typeIdDef;
    if (asArray) {
        typeIdDef = typeSer.writeTypePrefix(g,
                typeSer.typeId(value, JsonToken.START_ARRAY));
        _writeArrayContents(g, value);
    } else { // default is to write as simple String
        typeIdDef = typeSer.writeTypePrefix(g,
                typeSer.typeId(value, JsonToken.VALUE_STRING));
        g.writeString(value, 0, value.length);
    }
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(Object bean, JsonGenerator gen,
        SerializerProvider provider, TypeSerializer typeSer)
    throws IOException
{
    /* 10-Dec-2014, tatu: Not sure if this can be made to work reliably;
     *   but for sure delegating to default implementation will not work. So:
     */
    if (_objectIdWriter != null) {
        _serializeWithObjectId(bean, gen, provider, typeSer);
        return;
    }
    gen.setCurrentValue(bean);
    WritableTypeId typeIdDef = _typeIdDef(typeSer, bean, JsonToken.START_ARRAY);
    typeSer.writeTypePrefix(gen, typeIdDef);
    serializeAsArray(bean, gen, provider);
    typeSer.writeTypeSuffix(gen, typeIdDef);
}
 

@Override
public void serializeWithType(JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    @SuppressWarnings("deprecation")
    boolean trimEmptyArray = (provider != null) &&
            !provider.isEnabled(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS);

    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(this, JsonToken.START_OBJECT));
    for (Map.Entry<String, JsonNode> en : _children.entrySet()) {
        BaseJsonNode value = (BaseJsonNode) en.getValue();

        // check if WRITE_EMPTY_JSON_ARRAYS feature is disabled,
        // if the feature is disabled, then should not write an empty array
        // to the output, so continue to the next element in the iteration
        if (trimEmptyArray && value.isArray() && value.isEmpty(provider)) {
            continue;
        }
        
        g.writeFieldName(en.getKey());
        value.serialize(g, provider);
    }
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
    public void serializeWithType(Multimap<?,?> value, JsonGenerator gen,
            SerializerProvider ctxt, TypeSerializer typeSer)
        throws IOException
    {
        gen.setCurrentValue(value);
        WritableTypeId typeIdDef = typeSer.writeTypePrefix(gen, ctxt,
                typeSer.typeId(value, JsonToken.START_OBJECT));
        if (!value.isEmpty()) {
// 20-Mar-2017, tatu: And this is where [datatypes-collections#7] would be
//     plugged in...
//            if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
//              value = _orderEntries(value, gen, provider);
//          }
            if (_filterId != null) {
                serializeFilteredFields(value, gen, ctxt);
            } else {
                serializeFields(value, gen, ctxt);
            }
        }
        typeSer.writeTypeSuffix(gen, ctxt, typeIdDef);
    }
 

@Override
public void serializeWithType(
        CharIterable value,
        JsonGenerator g,
        SerializerProvider ctxt,
        TypeSerializer typeSer
) throws IOException {
    g.setCurrentValue(value);
    WritableTypeId typeIdDef;
    if (ctxt.isEnabled(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS)) {
        typeIdDef = typeSer.writeTypePrefix(g, ctxt, typeSer.typeId(value, JsonToken.START_ARRAY));
        writeContentsAsArray(value, g);
    } else {
        typeIdDef = typeSer.writeTypePrefix(g, ctxt, typeSer.typeId(value, JsonToken.VALUE_STRING));
        char[] chars = value.toArray();
        g.writeString(chars, 0, chars.length);
    }
    typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
 

@Override
public void serializeWithType(LocalDateTime value, JsonGenerator g, SerializerProvider ctxt,
        TypeSerializer typeSer) throws IOException
{
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g, ctxt,
            typeSer.typeId(value, serializationShape(ctxt)));
    // need to write out to avoid double-writing array markers
    if (typeIdDef.valueShape == JsonToken.START_ARRAY) {
        _serializeAsArrayContents(value, g, ctxt);
    } else {
        DateTimeFormatter dtf = _formatter;
        if (dtf == null) {
            dtf = _defaultFormatter();
        }
        g.writeString(value.format(dtf));
    }
    typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
 

@Override
public void serializeWithType(LocalTime value, JsonGenerator g,
        SerializerProvider ctxt, TypeSerializer typeSer) throws IOException
{
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g, ctxt,
            typeSer.typeId(value, serializationShape(ctxt)));
    // need to write out to avoid double-writing array markers
    if (typeIdDef.valueShape == JsonToken.START_ARRAY) {
        _serializeAsArrayContents(value, g, ctxt);
    } else {
        DateTimeFormatter dtf = _formatter;
        if (dtf == null) {
            dtf = _defaultFormatter();
        }
        g.writeString(value.format(dtf));
    }
    typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
 

@Override
public void serializeWithType(LocalDate value, JsonGenerator g,
        SerializerProvider ctxt, TypeSerializer typeSer) throws IOException
{
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g, ctxt,
            typeSer.typeId(value, serializationShape(ctxt)));
    // need to write out to avoid double-writing array markers
    switch (typeIdDef.valueShape) {
    case START_ARRAY:
        _serializeAsArrayContents(value, g, ctxt);
        break;
    case VALUE_NUMBER_INT:
        g.writeNumber(value.toEpochDay());
        break;
    default:
        g.writeString((_formatter == null) ? value.toString() : value.format(_formatter));
    }
    typeSer.writeTypeSuffix(g, ctxt, typeIdDef);
}
 

@Override
public void serializeWithType(
    AwsCredentialsProvider credentialsProvider,
    JsonGenerator jsonGenerator,
    SerializerProvider serializer,
    TypeSerializer typeSerializer)
    throws IOException {
  WritableTypeId typeId =
      typeSerializer.writeTypePrefix(
          jsonGenerator, typeSerializer.typeId(credentialsProvider, JsonToken.START_OBJECT));
  if (credentialsProvider.getClass().equals(StaticCredentialsProvider.class)) {
    jsonGenerator.writeStringField(
        ACCESS_KEY_ID, credentialsProvider.resolveCredentials().accessKeyId());
    jsonGenerator.writeStringField(
        SECRET_ACCESS_KEY, credentialsProvider.resolveCredentials().secretAccessKey());
  } else if (!SINGLETON_CREDENTIAL_PROVIDERS.contains(credentialsProvider.getClass())) {
    throw new IllegalArgumentException(
        "Unsupported AWS credentials provider type " + credentialsProvider.getClass());
  }
  typeSerializer.writeTypeSuffix(jsonGenerator, typeId);
}
 

@Override
public void serializeWithType(Node value, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSer) throws IOException {
    WritableTypeId typeId = typeSer.typeId(value, Node.class, JsonToken.START_OBJECT);
    typeSer.writeTypePrefix(gen, typeId);
    serialize(value, gen, serializers);
    typeSer.writeTypeSuffix(gen, typeId);
}
 

@Override
public void serializeWithType(BinaryArg value, JsonGenerator gen, SerializerProvider provider, TypeSerializer typeSer) throws IOException {
    WritableTypeId typeId = typeSer.typeId(value, START_OBJECT);
    typeSer.writeTypePrefix(gen, typeId);
    serialize(value, gen, provider);
    typeSer.writeTypeSuffix(gen, typeId);
}
 

/**
 * Factory method for constructing type id value object to pass to
 * {@link #writeTypePrefix}.
 */
public WritableTypeId typeId(Object value, JsonToken valueShape) {
    WritableTypeId typeIdDef = new WritableTypeId(value, valueShape);
    switch (getTypeInclusion()) {
    case EXISTING_PROPERTY:
        typeIdDef.include = WritableTypeId.Inclusion.PAYLOAD_PROPERTY;
        typeIdDef.asProperty = getPropertyName();
        break;
    case EXTERNAL_PROPERTY:
        typeIdDef.include = WritableTypeId.Inclusion.PARENT_PROPERTY;
        typeIdDef.asProperty = getPropertyName();
        break;
    case PROPERTY:
        typeIdDef.include = WritableTypeId.Inclusion.METADATA_PROPERTY;
        typeIdDef.asProperty = getPropertyName();
        break;
    case WRAPPER_ARRAY:
        typeIdDef.include = WritableTypeId.Inclusion.WRAPPER_ARRAY;
        break;
    case WRAPPER_OBJECT:
        typeIdDef.include = WritableTypeId.Inclusion.WRAPPER_OBJECT;
        break;
    default:
        VersionUtil.throwInternal();
    }
    return typeIdDef;
}
 

/**
 * Helper method needed for backwards compatibility: since original type id
 * can not be routed through completely, we have to reverse-engineer likely
 * setting before calling suffix.
 *
 * @since 2.9
 */
protected final void _writeLegacySuffix(JsonGenerator g,
        WritableTypeId typeId) throws IOException
{
    // most likely logic within generator is this:
    typeId.wrapperWritten = !g.canWriteTypeId();
    writeTypeSuffix(g, typeId);
}
 

@Override
public WritableTypeId writeTypePrefix(JsonGenerator g,
        WritableTypeId idMetadata) throws IOException
{
    _generateTypeId(idMetadata);
    return g.writeTypePrefix(idMetadata);
}
 

/**
 * Helper method that will generate type id to use, if not already passed.
 *
 * @since 2.9
 */
protected void _generateTypeId(WritableTypeId idMetadata) {
    Object id = idMetadata.id;
    if (id == null) {
        final Object value = idMetadata.forValue;
        Class<?> typeForId = idMetadata.forValueType;
        if (typeForId == null) {
            id = idFromValue(value);
        } else {
            id = idFromValueAndType(value, typeForId);
        }
        idMetadata.id = id;
    }
}
 

/**
 * Implementing typed output for contents of a TokenBuffer is very tricky,
 * since we do not know for sure what its contents might look like (or, rather,
 * we do know when serializing, but not necessarily when deserializing!)
 * One possibility would be to check the current token, and use that to
 * determine if we would output JSON Array, Object or scalar value.
 *<p>
 * Note that we just claim it is scalar; this should work ok and is simpler
 * than doing introspection on both serialization and deserialization.
 */
@Override
public final void serializeWithType(TokenBuffer value, JsonGenerator g,
        SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
    // 28-Jun-2017, tatu: As per javadoc, not sure what to report as likely shape. Could
    //    even look into first actual token inside... but, for now let's keep it simple
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.VALUE_EMBEDDED_OBJECT));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(Object bean, JsonGenerator gen, SerializerProvider provider,
        TypeSerializer typeSer0) throws IOException
{
    // Regardless of other parts, first need to find value to serialize:
    Object value = null;
    try {
        value = _accessor.getValue(bean);
        // and if we got null, can also just write it directly
        if (value == null) {
            provider.defaultSerializeNull(gen);
            return;
        }
        JsonSerializer<Object> ser = _valueSerializer;
        if (ser == null) { // no serializer yet? Need to fetch
            ser = provider.findValueSerializer(value.getClass(), _property);
        } else {
            // 09-Dec-2010, tatu: To work around natural type's refusal to add type info, we do
            //    this (note: type is for the wrapper type, not enclosed value!)
            if (_forceTypeInformation) {
                // Confusing? Type id is for POJO and NOT for value returned by JsonValue accessor...
                WritableTypeId typeIdDef = typeSer0.writeTypePrefix(gen,
                        typeSer0.typeId(bean, JsonToken.VALUE_STRING));
                ser.serialize(value, gen, provider);
                typeSer0.writeTypeSuffix(gen, typeIdDef);

                return;
            }
        }
        // 28-Sep-2016, tatu: As per [databind#1385], we do need to do some juggling
        //    to use different Object for type id (logical type) and actual serialization
        //    (delegat type).
        TypeSerializerRerouter rr = new TypeSerializerRerouter(typeSer0, bean);
        ser.serializeWithType(value, gen, provider, rr);
    } catch (Exception e) {
        wrapAndThrow(provider, e, bean, _accessor.getName() + "()");
    }
}
 

@Override // since 2.9
public WritableTypeId writeTypePrefix(JsonGenerator g,
        WritableTypeId typeId) throws IOException {
    // 28-Jun-2017, tatu: Important! Need to "override" value
    typeId.forValue = _forObject;
    return _typeSerializer.writeTypePrefix(g, typeId);
}
 

@Override
public void serializeWithType(InetAddress value, JsonGenerator g,
        SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
    // Better ensure we don't use specific sub-classes...
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, InetAddress.class, JsonToken.VALUE_STRING));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(TimeZone value, JsonGenerator g,
        SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
    // Better ensure we don't use specific sub-classes:
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, TimeZone.class, JsonToken.VALUE_STRING));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

/**
 * Default implementation will write type prefix, call regular serialization
 * method (since assumption is that value itself does not need JSON
 * Array or Object start/end markers), and then write type suffix.
 * This should work for most cases; some sub-classes may want to
 * change this behavior.
 */
@Override
public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer) throws IOException
{
    // NOTE: need not really be string; just indicates "scalar of some kind"
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.VALUE_STRING));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(InetSocketAddress value, JsonGenerator g,
        SerializerProvider provider, TypeSerializer typeSer) throws IOException
{
    // Better ensure we don't use specific sub-classes...
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, InetSocketAddress.class, JsonToken.VALUE_STRING));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

/**
 * Default implementation will write type prefix, call regular serialization
 * method (since assumption is that value itself does not need JSON
 * Array or Object start/end markers), and then write type suffix.
 * This should work for most cases; some sub-classes may want to
 * change this behavior.
 */
@Override
public void serializeWithType(Object value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.VALUE_STRING));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer) throws IOException
{
    // [databind#631]: Assign current value, to be accessible by custom serializers
    g.setCurrentValue(value);
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.START_ARRAY));
    serializeContents(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public final void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    // [databind#631]: Assign current value, to be accessible by custom serializers
    g.setCurrentValue(value);
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.START_ARRAY));
    serializeContents(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}
 

@Override
public void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
        TypeSerializer typeSer)
    throws IOException
{
    WritableTypeId typeIdDef = typeSer.writeTypePrefix(g,
            typeSer.typeId(value, JsonToken.VALUE_EMBEDDED_OBJECT));
    serialize(value, g, provider);
    typeSer.writeTypeSuffix(g, typeIdDef);
}