Java 类com.fasterxml.jackson.databind.util.NameTransformer 实例源码

public final BeanPropertyMap renameAll(NameTransformer paramNameTransformer)
{
  if ((paramNameTransformer == null) || (paramNameTransformer == NameTransformer.NOP))
    return this;
  Iterator localIterator = iterator();
  ArrayList localArrayList = new ArrayList();
  while (localIterator.hasNext())
  {
    SettableBeanProperty localSettableBeanProperty1 = (SettableBeanProperty)localIterator.next();
    SettableBeanProperty localSettableBeanProperty2 = localSettableBeanProperty1.withName(paramNameTransformer.transform(localSettableBeanProperty1.getName()));
    SettableBeanProperty localSettableBeanProperty3 = localSettableBeanProperty2;
    JsonDeserializer localJsonDeserializer1 = localSettableBeanProperty2.getValueDeserializer();
    if (localJsonDeserializer1 != null)
    {
      JsonDeserializer localJsonDeserializer2 = localJsonDeserializer1.unwrappingDeserializer(paramNameTransformer);
      if (localJsonDeserializer2 != localJsonDeserializer1)
        localSettableBeanProperty3 = localSettableBeanProperty3.withValueDeserializer(localJsonDeserializer2);
    }
    localArrayList.add(localSettableBeanProperty3);
  }
  return new BeanPropertyMap(localArrayList);
}

public UnwrappedPropertyHandler renameAll(NameTransformer paramNameTransformer)
{
  ArrayList localArrayList = new ArrayList(this._properties.size());
  Iterator localIterator = this._properties.iterator();
  while (localIterator.hasNext())
  {
    SettableBeanProperty localSettableBeanProperty1 = (SettableBeanProperty)localIterator.next();
    SettableBeanProperty localSettableBeanProperty2 = localSettableBeanProperty1.withName(paramNameTransformer.transform(localSettableBeanProperty1.getName()));
    SettableBeanProperty localSettableBeanProperty3 = localSettableBeanProperty2;
    JsonDeserializer localJsonDeserializer1 = localSettableBeanProperty2.getValueDeserializer();
    if (localJsonDeserializer1 != null)
    {
      JsonDeserializer localJsonDeserializer2 = localJsonDeserializer1.unwrappingDeserializer(paramNameTransformer);
      if (localJsonDeserializer2 != localJsonDeserializer1)
        localSettableBeanProperty3 = localSettableBeanProperty3.withValueDeserializer(localJsonDeserializer2);
    }
    localArrayList.add(localSettableBeanProperty3);
  }
  return new UnwrappedPropertyHandler(localArrayList);
}

protected SettableBeanProperty _resolveUnwrappedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty)
{
  AnnotatedMember localAnnotatedMember = paramSettableBeanProperty.getMember();
  if (localAnnotatedMember != null)
  {
    NameTransformer localNameTransformer = paramDeserializationContext.getAnnotationIntrospector().findUnwrappingNameTransformer(localAnnotatedMember);
    if (localNameTransformer != null)
    {
      JsonDeserializer localJsonDeserializer1 = paramSettableBeanProperty.getValueDeserializer();
      JsonDeserializer localJsonDeserializer2 = localJsonDeserializer1.unwrappingDeserializer(localNameTransformer);
      if ((localJsonDeserializer2 != localJsonDeserializer1) && (localJsonDeserializer2 != null))
        return paramSettableBeanProperty.withValueDeserializer(localJsonDeserializer2);
    }
  }
  return null;
}

private final static BeanPropertyWriter[] rename(BeanPropertyWriter[] props,
        NameTransformer transformer)
{
    if (props == null || props.length == 0 || transformer == null || transformer == NameTransformer.NOP) {
        return props;
    }
    final int len = props.length;
    BeanPropertyWriter[] result = new BeanPropertyWriter[len];
    for (int i = 0; i < len; ++i) {
        BeanPropertyWriter bpw = props[i];
        if (bpw != null) {
            result[i] = bpw.rename(transformer);
        }
    }
    return result;
}

@Override
protected JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
        Class<?> type, SerializerProvider provider) throws JsonMappingException
{
    JsonSerializer<Object> serializer;
    if (_nonTrivialBaseType != null) {
        JavaType subtype = provider.constructSpecializedType(_nonTrivialBaseType, type);
        serializer = provider.findValueSerializer(subtype, this);
    } else {
        serializer = provider.findValueSerializer(type, this);
    }
    NameTransformer t = _nameTransformer;
    if (serializer.isUnwrappingSerializer()) {
        t = NameTransformer.chainedTransformer(t, ((UnwrappingBeanSerializer) serializer)._nameTransformer);
    }
    serializer = serializer.unwrappingSerializer(t);

    _dynamicSerializers = _dynamicSerializers.newWith(type, serializer);
    return serializer;
}

/**
 * Factory method for constructing a map where all entries use given
 * prefix
 */
public BeanPropertyMap renameAll(NameTransformer transformer)
{
    if (transformer == null || (transformer == NameTransformer.NOP)) {
        return this;
    }
    Iterator<SettableBeanProperty> it = iterator();
    ArrayList<SettableBeanProperty> newProps = new ArrayList<SettableBeanProperty>();
    while (it.hasNext()) {
        SettableBeanProperty prop = it.next();
        String newName = transformer.transform(prop.getName());
        prop = prop.withName(newName);
        JsonDeserializer<?> deser = prop.getValueDeserializer();
        if (deser != null) {
            @SuppressWarnings("unchecked")
            JsonDeserializer<Object> newDeser = (JsonDeserializer<Object>)
                deser.unwrappingDeserializer(transformer);
            if (newDeser != deser) {
                prop = prop.withValueDeserializer(newDeser);
            }
        }
        newProps.add(prop);
    }
    // should we try to re-index? Ordering probably changed but called probably doesn't want changes...
    return new BeanPropertyMap(newProps);
}

public void renameAll(NameTransformer transformer)
{
    ArrayList<SettableBeanProperty> oldProps = new ArrayList<SettableBeanProperty>(_properties);
    Iterator<SettableBeanProperty> it = oldProps.iterator();
    _properties.clear();
    while (it.hasNext()) {
        SettableBeanProperty prop = it.next();
        String newName = transformer.transform(prop.getName());
        prop = prop.withName(newName);
        JsonDeserializer<?> deser = prop.getValueDeserializer();
        if (deser != null) {
            @SuppressWarnings("unchecked")
            JsonDeserializer<Object> newDeser = (JsonDeserializer<Object>)
                deser.unwrappingDeserializer(transformer);
            if (newDeser != deser) {
                prop = prop.withValueDeserializer(newDeser);
            }
        }
        _properties.add(prop);
    }
}

/**
 * {@inheritDoc}
 * 
 * Not used
 */
@Override
public JsonDeserializer<Object> unwrappingDeserializer(
        NameTransformer unwrapper) {
    // Not used
    return null;
}

public BeanPropertyWriter rename(NameTransformer transformer) {
    String newName = transformer.transform(_name.getValue());
    if (newName.equals(_name.toString())) {
        return this;
    }
    return new BeanPropertyWriter(this, new SerializedString(newName));
}

private static final BeanPropertyWriter[] rename(BeanPropertyWriter[] paramArrayOfBeanPropertyWriter, NameTransformer paramNameTransformer)
{
  if ((paramArrayOfBeanPropertyWriter == null) || (paramArrayOfBeanPropertyWriter.length == 0) || (paramNameTransformer == null) || (paramNameTransformer == NameTransformer.NOP))
    return paramArrayOfBeanPropertyWriter;
  int i = paramArrayOfBeanPropertyWriter.length;
  BeanPropertyWriter[] arrayOfBeanPropertyWriter = new BeanPropertyWriter[i];
  for (int j = 0; j < i; j++)
  {
    BeanPropertyWriter localBeanPropertyWriter = paramArrayOfBeanPropertyWriter[j];
    if (localBeanPropertyWriter != null)
      arrayOfBeanPropertyWriter[j] = localBeanPropertyWriter.rename(paramNameTransformer);
  }
  return arrayOfBeanPropertyWriter;
}

public BeanPropertyWriter rename(NameTransformer paramNameTransformer)
{
  String str = paramNameTransformer.transform(this._name.getValue());
  if (str.equals(this._name.toString()))
    return this;
  return new BeanPropertyWriter(this, new SerializedString(str));
}

protected JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap paramPropertySerializerMap, Class<?> paramClass, SerializerProvider paramSerializerProvider)
{
  JsonSerializer localJsonSerializer1;
  if (this._nonTrivialBaseType != null)
    localJsonSerializer1 = paramSerializerProvider.findValueSerializer(paramSerializerProvider.constructSpecializedType(this._nonTrivialBaseType, paramClass), this);
  else
    localJsonSerializer1 = paramSerializerProvider.findValueSerializer(paramClass, this);
  NameTransformer localNameTransformer = this._nameTransformer;
  if (localJsonSerializer1.isUnwrappingSerializer())
    localNameTransformer = NameTransformer.chainedTransformer(localNameTransformer, ((UnwrappingBeanSerializer)localJsonSerializer1)._nameTransformer);
  JsonSerializer localJsonSerializer2 = localJsonSerializer1.unwrappingSerializer(localNameTransformer);
  this._dynamicSerializers = this._dynamicSerializers.newWith(paramClass, localJsonSerializer2);
  return localJsonSerializer2;
}

public void assignSerializer(JsonSerializer<Object> paramJsonSerializer)
{
  super.assignSerializer(paramJsonSerializer);
  if (this._serializer != null)
  {
    NameTransformer localNameTransformer = this._nameTransformer;
    if (this._serializer.isUnwrappingSerializer())
      localNameTransformer = NameTransformer.chainedTransformer(localNameTransformer, ((UnwrappingBeanSerializer)this._serializer)._nameTransformer);
    this._serializer = this._serializer.unwrappingSerializer(localNameTransformer);
  }
}

public NameTransformer findUnwrappingNameTransformer(AnnotatedMember paramAnnotatedMember)
{
  NameTransformer localNameTransformer1 = this._primary.findUnwrappingNameTransformer(paramAnnotatedMember);
  NameTransformer localNameTransformer2 = localNameTransformer1;
  if (localNameTransformer1 == null)
    localNameTransformer2 = this._secondary.findUnwrappingNameTransformer(paramAnnotatedMember);
  return localNameTransformer2;
}

public NameTransformer findUnwrappingNameTransformer(AnnotatedMember paramAnnotatedMember)
{
  JsonUnwrapped localJsonUnwrapped = (JsonUnwrapped)paramAnnotatedMember.getAnnotation(JsonUnwrapped.class);
  if ((localJsonUnwrapped == null) || (!localJsonUnwrapped.enabled()))
    return null;
  return NameTransformer.simpleTransformer(localJsonUnwrapped.prefix(), localJsonUnwrapped.suffix());
}

protected BeanDeserializerBase(BeanDeserializerBase paramBeanDeserializerBase, NameTransformer paramNameTransformer)
{
  super(paramBeanDeserializerBase._beanType);
  this._classAnnotations = paramBeanDeserializerBase._classAnnotations;
  this._beanType = paramBeanDeserializerBase._beanType;
  this._valueInstantiator = paramBeanDeserializerBase._valueInstantiator;
  this._delegateDeserializer = paramBeanDeserializerBase._delegateDeserializer;
  this._propertyBasedCreator = paramBeanDeserializerBase._propertyBasedCreator;
  this._backRefs = paramBeanDeserializerBase._backRefs;
  this._ignorableProps = paramBeanDeserializerBase._ignorableProps;
  boolean bool;
  if ((paramNameTransformer != null) || (paramBeanDeserializerBase._ignoreAllUnknown))
    bool = true;
  else
    bool = false;
  this._ignoreAllUnknown = bool;
  this._anySetter = paramBeanDeserializerBase._anySetter;
  this._injectables = paramBeanDeserializerBase._injectables;
  this._objectIdReader = paramBeanDeserializerBase._objectIdReader;
  this._nonStandardCreation = paramBeanDeserializerBase._nonStandardCreation;
  UnwrappedPropertyHandler localUnwrappedPropertyHandler = paramBeanDeserializerBase._unwrappedPropertyHandler;
  if (paramNameTransformer != null)
  {
    if (localUnwrappedPropertyHandler != null)
      localUnwrappedPropertyHandler = localUnwrappedPropertyHandler.renameAll(paramNameTransformer);
    this._beanProperties = paramBeanDeserializerBase._beanProperties.renameAll(paramNameTransformer);
  }
  else
  {
    this._beanProperties = paramBeanDeserializerBase._beanProperties;
  }
  this._unwrappedPropertyHandler = localUnwrappedPropertyHandler;
  this._needViewProcesing = paramBeanDeserializerBase._needViewProcesing;
  this._serializationShape = paramBeanDeserializerBase._serializationShape;
  this._vanillaProcessing = false;
}

public BeanPropertyWriter rename(NameTransformer transformer) {
    String newName = transformer.transform(_name.getValue());
    if (newName.equals(_name.toString())) {
        return this;
    }
    return new BeanPropertyWriter(this, new SerializedString(newName));
}

@Override
public UnwrappingBeanPropertyWriter rename(NameTransformer transformer)
{
    String oldName = _name.getValue();
    String newName = transformer.transform(oldName);

    // important: combine transformers:
    transformer = NameTransformer.chainedTransformer(transformer, _nameTransformer);

    return new UnwrappingBeanPropertyWriter(this, transformer, new SerializedString(newName));
}

@Override
public void assignSerializer(JsonSerializer<Object> ser)
{
    super.assignSerializer(ser);
    if (_serializer != null) {
        NameTransformer t = _nameTransformer;
        if (_serializer.isUnwrappingSerializer()) {
            t = NameTransformer.chainedTransformer(t, ((UnwrappingBeanSerializer) _serializer)._nameTransformer);
        }
        _serializer = _serializer.unwrappingSerializer(t);
    }
}

@Override
public JsonSerializer<Object> unwrappingSerializer(NameTransformer transformer) {
    /* If this gets called, we will just need delegate to the default
     * serializer, to "undo" as-array serialization
     */
    return _defaultSerializer.unwrappingSerializer(transformer);
}

@Override        
public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member)
{
    NameTransformer value = _primary.findUnwrappingNameTransformer(member);
    if (value == null) {
        value = _secondary.findUnwrappingNameTransformer(member);
    }
    return value;
}

@Override
public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member)
{
    JsonUnwrapped ann = member.getAnnotation(JsonUnwrapped.class);
    // if not enabled, just means annotation is not enabled; not necessarily
    // that unwrapping should not be done (relevant when using chained introspectors)
    if (ann == null || !ann.enabled()) {
        return null;
    }
    String prefix = ann.prefix();
    String suffix = ann.suffix();
    return NameTransformer.simpleTransformer(prefix, suffix);
}

@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
    /* bit kludgy but we don't want to accidentally change type; sub-classes
     * MUST override this method to support unwrapped properties...
     */
    if (getClass() != BeanDeserializer.class) {
        return this;
    }
    /* main thing really is to just enforce ignoring of unknown
     * properties; since there may be multiple unwrapped values
     * and properties for all may be interleaved...
     */
    return new BeanDeserializer(this, unwrapper);
}

@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
    if (getClass() != ThrowableDeserializer.class) {
        return this;
    }
    /* main thing really is to just enforce ignoring of unknown
     * properties; since there may be multiple unwrapped values
     * and properties for all may be interleaved...
     */
    return new ThrowableDeserializer(this, unwrapper);
}

@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
    /* main thing really is to just enforce ignoring of unknown
     * properties; since there may be multiple unwrapped values
     * and properties for all may be interleaved...
     */
    return new BuilderBasedDeserializer(this, unwrapper);
}

@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
    /* We can't do much about this; could either replace _delegate
     * with unwrapping instance, or just replace this one. Latter seems
     * more sensible.
     */
    return _delegate.unwrappingDeserializer(unwrapper);
}

@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
    /* We can't do much about this; could either replace _delegate
     * with unwrapping instance, or just replace this one. Latter seems
     * more sensible.
     */
    return _delegate.unwrappingDeserializer(unwrapper);
}

/**
 * {@inheritDoc}
 * 
 * Not used
 */
@Override
public JsonDeserializer<Object> unwrappingDeserializer(
        NameTransformer unwrapper) {
    // Not used
    return null;
}

public JsonSerializer<T> unwrappingSerializer(NameTransformer paramNameTransformer)
{
  return this;
}

public JsonDeserializer<T> unwrappingDeserializer(NameTransformer paramNameTransformer)
{
  return this;
}

public BeanSerializerBase(BeanSerializerBase paramBeanSerializerBase, NameTransformer paramNameTransformer)
{
  this(paramBeanSerializerBase, rename(paramBeanSerializerBase._props, paramNameTransformer), rename(paramBeanSerializerBase._filteredProps, paramNameTransformer));
}

public BeanPropertyWriter unwrappingWriter(NameTransformer paramNameTransformer)
{
  return new UnwrappingBeanPropertyWriter(this, paramNameTransformer);
}

public UnwrappingBeanPropertyWriter(BeanPropertyWriter paramBeanPropertyWriter, NameTransformer paramNameTransformer)
{
  super(paramBeanPropertyWriter);
  this._nameTransformer = paramNameTransformer;
}

private UnwrappingBeanPropertyWriter(UnwrappingBeanPropertyWriter paramUnwrappingBeanPropertyWriter, NameTransformer paramNameTransformer, SerializedString paramSerializedString)
{
  super(paramUnwrappingBeanPropertyWriter, paramSerializedString);
  this._nameTransformer = paramNameTransformer;
}

public UnwrappingBeanPropertyWriter rename(NameTransformer paramNameTransformer)
{
  String str = paramNameTransformer.transform(this._name.getValue());
  return new UnwrappingBeanPropertyWriter(this, NameTransformer.chainedTransformer(paramNameTransformer, this._nameTransformer), new SerializedString(str));
}

public JsonSerializer<Object> unwrappingSerializer(NameTransformer paramNameTransformer)
{
  return this._defaultSerializer.unwrappingSerializer(paramNameTransformer);
}

public UnwrappingBeanSerializer(BeanSerializerBase paramBeanSerializerBase, NameTransformer paramNameTransformer)
{
  super(paramBeanSerializerBase, paramNameTransformer);
  this._nameTransformer = paramNameTransformer;
}

public JsonSerializer<Object> unwrappingSerializer(NameTransformer paramNameTransformer)
{
  return new UnwrappingBeanSerializer(this, paramNameTransformer);
}

public final MultiView rename(NameTransformer paramNameTransformer)
{
  return new MultiView(this._delegate.rename(paramNameTransformer), this._views);
}

public final SingleView rename(NameTransformer paramNameTransformer)
{
  return new SingleView(this._delegate.rename(paramNameTransformer), this._view);
}