java.net.bytebuddy.dynamic.scaffold.FieldRegistry Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of securemock Show documentation
Show all versions of securemock Show documentation
Libraries for Elasticsearch
The newest version!
/*
* Copyright 2014 - 2018 Rafael Winterhalter
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.bytebuddy.dynamic.scaffold;
import net.bytebuddy.build.HashCodeAndEqualsPlugin;
import net.bytebuddy.description.field.FieldDescription;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.Transformer;
import net.bytebuddy.implementation.attribute.FieldAttributeAppender;
import net.bytebuddy.matcher.ElementMatcher;
import net.bytebuddy.matcher.LatentMatcher;
import java.util.*;
/**
* A field registry represents an extendable collection of fields which are identified by their names that are mapped
* to a given {@link net.bytebuddy.implementation.attribute.FieldAttributeAppender}. Fields
* can be uniquely identified by their name for a given type since fields are never inherited.
*
* This registry is the counterpart of a {@link net.bytebuddy.dynamic.scaffold.MethodRegistry}.
* However, a field registry is implemented simpler since it does not have to deal with complex signatures or
* inheritance. For the sake of consistency, the field registry follows however a similar pattern without introducing
* unnecessary complexity.
*/
public interface FieldRegistry {
/**
* Prepends the given field definition to this field registry, i.e. this configuration is applied first.
*
* @param matcher The matcher to identify any field that this definition concerns.
* @param fieldAttributeAppenderFactory The field attribute appender factory to apply on any matched field.
* @param defaultValue The default value to write to the field or {@code null} if no default value is to be set for the field.
* @param transformer The field transformer to apply to any matched field.
* @return An adapted version of this method registry.
*/
FieldRegistry prepend(LatentMatcher matcher,
FieldAttributeAppender.Factory fieldAttributeAppenderFactory,
Object defaultValue,
Transformer transformer);
/**
* Prepares the field registry for a given instrumented type.
*
* @param instrumentedType The instrumented type.
* @return A prepared field registry.
*/
Compiled compile(TypeDescription instrumentedType);
/**
* Represents a compiled field registry.
*/
interface Compiled extends TypeWriter.FieldPool {
/**
* A no-op field registry that does not register annotations for any field.
*/
enum NoOp implements Compiled {
/**
* The singleton instance.
*/
INSTANCE;
/**
* {@inheritDoc}
*/
public Record target(FieldDescription fieldDescription) {
return new Record.ForImplicitField(fieldDescription);
}
}
}
/**
* An immutable default implementation of a field registry.
*/
@HashCodeAndEqualsPlugin.Enhance
class Default implements FieldRegistry {
/**
* This registries entries.
*/
private final List entries;
/**
* Creates a new empty default field registry.
*/
public Default() {
this(Collections.emptyList());
}
/**
* Creates a new default field registry.
*
* @param entries The entries of the field registry.
*/
private Default(List entries) {
this.entries = entries;
}
/**
* {@inheritDoc}
*/
public FieldRegistry prepend(LatentMatcher matcher,
FieldAttributeAppender.Factory fieldAttributeAppenderFactory,
Object defaultValue,
Transformer transformer) {
List entries = new ArrayList(this.entries.size() + 1);
entries.add(new Entry(matcher, fieldAttributeAppenderFactory, defaultValue, transformer));
entries.addAll(this.entries);
return new Default(entries);
}
/**
* {@inheritDoc}
*/
public FieldRegistry.Compiled compile(TypeDescription instrumentedType) {
List entries = new ArrayList(this.entries.size());
Map fieldAttributeAppenders = new HashMap();
for (Entry entry : this.entries) {
FieldAttributeAppender fieldAttributeAppender = fieldAttributeAppenders.get(entry.getFieldAttributeAppenderFactory());
if (fieldAttributeAppender == null) {
fieldAttributeAppender = entry.getFieldAttributeAppenderFactory().make(instrumentedType);
fieldAttributeAppenders.put(entry.getFieldAttributeAppenderFactory(), fieldAttributeAppender);
}
entries.add(new Compiled.Entry(entry.resolve(instrumentedType), fieldAttributeAppender, entry.getDefaultValue(), entry.getTransformer()));
}
return new Compiled(instrumentedType, entries);
}
/**
* An entry of the default field registry.
*/
@HashCodeAndEqualsPlugin.Enhance
protected static class Entry implements LatentMatcher {
/**
* The matcher to identify any field that this definition concerns.
*/
private final LatentMatcher matcher;
/**
* The field attribute appender factory to apply on any matched field.
*/
private final FieldAttributeAppender.Factory fieldAttributeAppenderFactory;
/**
* The default value to write to the field or {@code null} if no default value is to be set for the field.
*/
private final Object defaultValue;
/**
* The field transformer to apply to any matched field.
*/
private final Transformer transformer;
/**
* Creates a new entry.
*
* @param matcher The matcher to identify any field that this definition concerns.
* @param fieldAttributeAppenderFactory The field attribute appender factory to apply on any matched field.
* @param defaultValue The default value to write to the field or {@code null} if no default value is to be set for the field.
* @param transformer The field transformer to apply to any matched field.
*/
protected Entry(LatentMatcher matcher,
FieldAttributeAppender.Factory fieldAttributeAppenderFactory,
Object defaultValue,
Transformer transformer) {
this.matcher = matcher;
this.fieldAttributeAppenderFactory = fieldAttributeAppenderFactory;
this.defaultValue = defaultValue;
this.transformer = transformer;
}
/**
* Returns the field attribute appender factory to apply on any matched field.
*
* @return The field attribute appender factory to apply on any matched field.
*/
protected FieldAttributeAppender.Factory getFieldAttributeAppenderFactory() {
return fieldAttributeAppenderFactory;
}
/**
* Returns the default value to write to the field or {@code null} if no default value is to be set for the field.
*
* @return The default value to write to the field or {@code null} if no default value is to be set for the field.
*/
protected Object getDefaultValue() {
return defaultValue;
}
/**
* Returns the field transformer to apply to any matched field.
*
* @return The field transformer to apply to any matched field.
*/
protected Transformer getTransformer() {
return transformer;
}
/**
* {@inheritDoc}
*/
public ElementMatcher resolve(TypeDescription typeDescription) {
return matcher.resolve(typeDescription);
}
}
/**
* A compiled default field registry.
*/
@HashCodeAndEqualsPlugin.Enhance
protected static class Compiled implements FieldRegistry.Compiled {
/**
* The instrumented type for which this registry was compiled for.
*/
private final TypeDescription instrumentedType;
/**
* The entries of this compiled field registry.
*/
private final List entries;
/**
* Creates a new compiled field registry.
*
* @param instrumentedType The instrumented type for which this registry was compiled for.
* @param entries The entries of this compiled field registry.
*/
protected Compiled(TypeDescription instrumentedType, List entries) {
this.instrumentedType = instrumentedType;
this.entries = entries;
}
/**
* {@inheritDoc}
*/
public Record target(FieldDescription fieldDescription) {
for (Entry entry : entries) {
if (entry.matches(fieldDescription)) {
return entry.bind(instrumentedType, fieldDescription);
}
}
return new Record.ForImplicitField(fieldDescription);
}
/**
* An entry of a compiled field registry.
*/
@HashCodeAndEqualsPlugin.Enhance
protected static class Entry implements ElementMatcher {
/**
* The matcher to identify any field that this definition concerns.
*/
private final ElementMatcher matcher;
/**
* The field attribute appender to apply on any matched field.
*/
private final FieldAttributeAppender fieldAttributeAppender;
/**
* The default value to write to the field or {@code null} if no default value is to be set for the field.
*/
private final Object defaultValue;
/**
* The field transformer to apply to any matched field.
*/
private final Transformer transformer;
/**
* Creates a new entry.
*
* @param matcher The matcher to identify any field that this definition concerns.
* @param fieldAttributeAppender The field attribute appender to apply on any matched field.
* @param defaultValue The default value to write to the field or {@code null} if no default value is to be set for the field.
* @param transformer The field transformer to apply to any matched field.
*/
protected Entry(ElementMatcher matcher,
FieldAttributeAppender fieldAttributeAppender,
Object defaultValue,
Transformer transformer) {
this.matcher = matcher;
this.fieldAttributeAppender = fieldAttributeAppender;
this.defaultValue = defaultValue;
this.transformer = transformer;
}
/**
* Binds this entry to the provided field description.
*
* @param instrumentedType The instrumented type for which this entry applies.
* @param fieldDescription The field description to be bound to this entry.
* @return A record representing the binding of this entry to the provided field.
*/
protected Record bind(TypeDescription instrumentedType, FieldDescription fieldDescription) {
return new Record.ForExplicitField(fieldAttributeAppender, defaultValue, transformer.transform(instrumentedType, fieldDescription));
}
/**
* {@inheritDoc}
*/
public boolean matches(FieldDescription target) {
return matcher.matches(target);
}
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy