How to use com.fasterxml.jackson.databind.deser.std

@Override
protected UUID _deserializeEmbedded(Object ob, DeserializationContext ctxt) throws IOException
{
  if (ob instanceof byte[]) {
    return _fromBytes((byte[]) ob, ctxt);
  }
  super._deserializeEmbedded(ob, ctxt);
  return null; // never gets here
}

/**
 * @since 2.9
 */
public EnumDeserializer withResolved(Boolean caseInsensitive) {
  if (_caseInsensitive == caseInsensitive) {
    return this;
  }
  return new EnumDeserializer(this, caseInsensitive);
}

public EnumSetDeserializer withDeserializer(JsonDeserializer<?> deser) {
  if (_enumDeserializer == deser) {
    return this;
  }
  return new EnumSetDeserializer(this, deser, _unwrapSingle);
}

/**
 * Factory method for accessing deserializer for specific node type
 */
public static JsonDeserializer<? extends JsonNode> getDeserializer(Class<?> nodeClass)
{
  if (nodeClass == ObjectNode.class) {
    return ObjectDeserializer.getInstance();
  }
  if (nodeClass == ArrayNode.class) {
    return ArrayDeserializer.getInstance();
  }
  // For others, generic one works fine
  return instance;
}

@Override // since 2.9
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
    BeanProperty property) throws JsonMappingException
{
  Boolean caseInsensitive = findFormatFeature(ctxt, property, handledType(),
      JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_PROPERTIES);
  if (caseInsensitive == null) {
    caseInsensitive = _caseInsensitive;
  }
  return withResolved(caseInsensitive);
}

@Override
public Float deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
  return _parseFloat(p, ctxt);
}

public static StringKD forType(Class<?> nominalType)
{
  if (nominalType == String.class) {
    return sString;
  }
  if (nominalType == Object.class) {
    return sObject;
  }
  return new StringKD(nominalType);
}

protected StringCollectionDeserializer withResolved(JsonDeserializer<?> delegateDeser,
    JsonDeserializer<?> valueDeser,
    NullValueProvider nuller, Boolean unwrapSingle)
{
  if ((_unwrapSingle == unwrapSingle) && (_nullProvider == nuller)
      && (_valueDeserializer == valueDeser) && (_delegateDeserializer == delegateDeser)) {
    return this;
  }
  return new StringCollectionDeserializer(_containerType, _valueInstantiator,
      delegateDeser, valueDeser, nuller, unwrapSingle);
}

@Override
protected PrimitiveArrayDeserializers<?> withResolved(NullValueProvider nuller,
    Boolean unwrapSingle) {
  return new ByteDeser(this, nuller, unwrapSingle);
}

@Override
protected short[] handleSingleElementUnwrapped(JsonParser p,
    DeserializationContext ctxt) throws IOException {
  return new short[] { _parseShortPrimitive(p, ctxt) };
}

  @Override
  public java.util.Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    return _parseDate(p, ctxt);
  }
}

@Override
protected int[] handleSingleElementUnwrapped(JsonParser p,
    DeserializationContext ctxt) throws IOException {
  return new int[] { _parseIntPrimitive(p, ctxt) };
}

@Override
public Short deserialize(JsonParser p, DeserializationContext ctxt)
  throws IOException
{
  return _parseShort(p, ctxt);
}

@Override
public JsonDeserializer<?> replaceDelegatee(JsonDeserializer<?> delegatee)
{
  if (delegatee == _delegatee) {
    return this;
  }
  return newDelegatingInstance(delegatee);
}

@Override
public AtomicReferenceDeserializer withResolved(TypeDeserializer typeDeser, JsonDeserializer<?> valueDeser) {
  return new AtomicReferenceDeserializer(_fullType, _valueInstantiator,
      typeDeser, valueDeser);
}
@Override

private static long _long(byte[] b, int offset) {
  long l1 = ((long) _int(b, offset)) << 32;
  long l2 = _int(b, offset+4);
  // faster to just do it than check if it has sign
  l2 = (l2 << 32) >>> 32; // to get rid of sign
  return l1 | l2;
}

  @Override
  public void handleResolvedForwardReference(Object id, Object value) throws IOException {
    _parent.resolveForwardReference(id, value);
  }
}

@Override // since 2.9
public Object getEmptyValue(DeserializationContext ctxt) throws JsonMappingException {
  Object empty = _emptyValue;
  if (empty == null) {
    _emptyValue = empty = _constructEmpty();
  }
  return empty;
}

public static Vanilla instance(boolean nonMerging) {
  if (nonMerging) {
    return new Vanilla(true);
  }
  return std;
}

public EnumSetDeserializer withResolved(JsonDeserializer<?> deser, Boolean unwrapSingle) {
  if ((_unwrapSingle == unwrapSingle) && (_enumDeserializer == deser)) {
    return this;
  }
  return new EnumSetDeserializer(this, deser, unwrapSingle);
}