How to use

XStreamImplicit

in

com.thoughtworks.xstream.annotations

@XStreamAlias("entitySelector")
public class EntitySelectorConfig extends SelectorConfig<EntitySelectorConfig> {
  @XStreamAsAttribute
  protected String id = null;
  @XStreamAsAttribute
  protected String mimicSelectorRef = null;
  protected SelectionOrder selectionOrder = null;
  @XStreamAlias("nearbySelection")
  protected NearbySelectionConfig nearbySelectionConfig = null;
  @XStreamImplicit(itemFieldName = "filterClass")
  protected List<Class<? extends SelectionFilter>> filterClassList = null;

final String itemFieldName = implicitAnnotation.itemFieldName();
final String keyFieldName = implicitAnnotation.keyFieldName();
boolean isMap = Map.class.isAssignableFrom(field.getType());
Class itemType = null;

@XmlRootElement(name="responses")
@XStreamAlias( "responses" )
@XmlAccessorType(XmlAccessType.FIELD)
public class ServiceResponsesList {

  @XmlElement(name = "response")
  @XStreamImplicit(itemFieldName = "response")
  private List<ServiceResponse<? extends Object>> responses;

  public ServiceResponsesList() {
    responses = new ArrayList<ServiceResponse<? extends Object>>();
  }

  public ServiceResponsesList(List<ServiceResponse<? extends Object>> responses) {
    this.responses = responses;
  }

  public List<ServiceResponse<? extends Object>> getResponses() {
    return responses;
  }

  public void setResponses(List<ServiceResponse<? extends Object>> responses) {
    this.responses = responses;
  }
}

@XmlRootElement(name = "kie-container")
@XStreamAlias( "kie-container" )
public class KieContainerResource {
  @XStreamAlias( "container-id" )
  private String             containerId;
  @XStreamAlias( "release-id" )
  private ReleaseId          releaseId;
  private KieScannerResource scanner;
  @XStreamImplicit
  private List<KieServerConfigItem> configItems = new ArrayList<KieServerConfigItem>();
  @XStreamImplicit
  private List<Message> messages = new ArrayList<Message>();

@XStreamAlias("module")
public class Module implements Comparable<String> {
 @XStreamAsAttribute
 private String name;
 @XStreamImplicit
 private List<Module> children;
 @XStreamImplicit(itemFieldName = "property")
 private List<Property> properties;
 @XStreamOmitField
 private String metadata;

@XStreamAlias("plannerBenchmarkResult")
public class PlannerBenchmarkResult {
  @XStreamOmitField // Moving or renaming a report directory after creation is allowed
  private File benchmarkReportDirectory;
  private EnvironmentMode environmentMode = null;
  @XStreamImplicit(itemFieldName = "solverBenchmarkResult")
  private List<SolverBenchmarkResult> solverBenchmarkResultList = null;
  @XStreamImplicit(itemFieldName = "unifiedProblemBenchmarkResult")
  private List<ProblemBenchmarkResult> unifiedProblemBenchmarkResultList = null;

@XStreamAlias("cartesianProductMoveSelector")
public class CartesianProductMoveSelectorConfig extends MoveSelectorConfig<CartesianProductMoveSelectorConfig> {
  @XStreamImplicit()
  private List<MoveSelectorConfig> moveSelectorConfigList = null;

@XStreamImplicit
private List<FilterGroup> filterGroupList;
@XStreamImplicit
private List<Filter> filterList;
@XStreamOmitField
protected String union;

public static class SubCategory {
  @Override
  public String toString() {
    return toSimpleString(this);
  }
  @XStreamImplicit(itemFieldName = "e")
  private List<Element> elements;
  @XStreamAsAttribute
  private String name;
  public List<Element> getElements() {
    return this.elements;
  }
  public void setElements(List<Element> elements) {
    this.elements = elements;
  }
}

protected SelectionOrder selectionOrder = null;
@XStreamImplicit(itemFieldName = "filterClass")
protected List<Class<? extends SelectionFilter>> filterClassList = null;

private void processImplicitAnnotation(final Field field) {
  final XStreamImplicit implicitAnnotation = field.getAnnotation(XStreamImplicit.class);
  if (implicitAnnotation != null) {
    if (implicitCollectionMapper == null) {
      throw new InitializationException("No "
        + ImplicitCollectionMapper.class.getName()
        + " available");
    }
    final String fieldName = field.getName();
    final String itemFieldName = implicitAnnotation.itemFieldName();
    Class itemType = null;
    final Type genericType = field.getGenericType();
    if (genericType instanceof ParameterizedType) {
      final Type typeArgument = ((ParameterizedType)genericType)
        .getActualTypeArguments()[0];
      itemType = getClass(typeArgument);
    }
    if (itemFieldName != null && !"".equals(itemFieldName)) {
      implicitCollectionMapper.add(
        field.getDeclaringClass(), fieldName, itemFieldName, itemType);
    } else {
      implicitCollectionMapper.add(field.getDeclaringClass(), fieldName, itemType);
    }
  }
}

@XmlRootElement(name="responses")
@XStreamAlias( "responses" )
@XmlAccessorType(XmlAccessType.FIELD)
public class ServiceResponsesList {

  @XmlElement(name = "response")
  @XStreamImplicit(itemFieldName = "response")
  private List<ServiceResponse<? extends Object>> responses;

  public ServiceResponsesList() {
    responses = new ArrayList<ServiceResponse<? extends Object>>();
  }

  public ServiceResponsesList(List<ServiceResponse<? extends Object>> responses) {
    this.responses = responses;
  }

  public List<ServiceResponse<? extends Object>> getResponses() {
    return responses;
  }

  public void setResponses(List<ServiceResponse<? extends Object>> responses) {
    this.responses = responses;
  }
}

@XStreamAlias("file")
public class FileNode {
 @XStreamImplicit(itemFieldName = "line")
 private List<LineNode> lines;
 @XStreamOmitField
 @XStreamImplicit(itemFieldName = "class")
 private List<ClassNode> ignoredNodes;
 @XStreamAlias("metrics")
 private MetricsNode metrics;
 @XStreamAsAttribute
 private String name;

@XStreamAlias("subSingleBenchmarkResult")
public class SubSingleBenchmarkResult implements BenchmarkResult {
  @XStreamOmitField // Bi-directional relationship restored through BenchmarkResultIO
  private SingleBenchmarkResult singleBenchmarkResult;
  private final int subSingleBenchmarkIndex;
  @XStreamImplicit(itemFieldName = "pureSubSingleStatistic")
  private List<PureSubSingleStatistic> pureSubSingleStatisticList = null;
  @XStreamOmitField // Lazily restored when read through ProblemStatistic and CSV files
  private Map<StatisticType, SubSingleStatistic> effectiveSubSingleStatisticMap;

@XStreamAlias("problemBenchmarks")
public class ProblemBenchmarksConfig extends AbstractConfig<ProblemBenchmarksConfig> {
  @XStreamImplicit(itemFieldName = "xStreamAnnotatedClass")
  private List<Class> xStreamAnnotatedClassList = null;
  private Boolean writeOutputSolutionEnabled = null;
  @XStreamImplicit(itemFieldName = "inputSolutionFile")
  private List<File> inputSolutionFileList = null;
  @XStreamImplicit(itemFieldName = "problemStatisticType")
  private List<ProblemStatisticType> problemStatisticTypeList = null;
  @XStreamImplicit(itemFieldName = "singleStatisticType")
  private List<SingleStatisticType> singleStatisticTypeList = null;

private Rectangle bounds = new Rectangle(0, 0);
@XStreamOmitField
private PrintComponent<?> parent;
@XStreamImplicit(itemFieldName = "component")
protected List<PrintComponent<?>> children = new ArrayList<PrintComponent<?>>();

private void processImplicitAnnotation(final Field field) {
  final XStreamImplicit implicitAnnotation = field.getAnnotation(XStreamImplicit.class);
  if (implicitAnnotation != null) {
    if (implicitCollectionMapper == null) {
      throw new InitializationException("No "
        + ImplicitCollectionMapper.class.getName()
        + " available");
    }
    final String fieldName = field.getName();
    final String itemFieldName = implicitAnnotation.itemFieldName();
    Class itemType = null;
    final Type genericType = field.getGenericType();
    if (genericType instanceof ParameterizedType) {
      final Type typeArgument = ((ParameterizedType)genericType)
        .getActualTypeArguments()[0];
      itemType = getClass(typeArgument);
    }
    if (itemFieldName != null && !"".equals(itemFieldName)) {
      implicitCollectionMapper.add(
        field.getDeclaringClass(), fieldName, itemFieldName, itemType);
    } else {
      implicitCollectionMapper.add(field.getDeclaringClass(), fieldName, itemType);
    }
  }
}

@XmlRootElement(name = "solvers")
@XStreamAlias("solvers")
@XmlAccessorType(XmlAccessType.FIELD)
public class SolverInstanceList {

  @XmlElement(name = "solver")
  @XStreamImplicit(itemFieldName = "solver")
  private List<SolverInstance> solvers;

  public SolverInstanceList() {
    solvers = new ArrayList<>();
  }

  public SolverInstanceList(List<SolverInstance> solvers) {
    this.solvers = solvers;
  }

  public List<SolverInstance> getContainers() {
    return solvers;
  }

  public void setContainers(List<SolverInstance> solvers) {
    this.solvers = solvers;
  }

}

@XStreamAlias("valueSelector")
public class ValueSelectorConfig extends SelectorConfig<ValueSelectorConfig> {
  @XStreamAsAttribute
  protected String id = null;
  @XStreamAsAttribute
  protected String mimicSelectorRef = null;
  @XStreamAsAttribute // Works with a nested element input too, which is a BC req in 7.x, but undesired in 8.0
  protected String variableName = null;
  protected SelectionOrder selectionOrder = null;
  @XStreamAlias("nearbySelection")
  protected NearbySelectionConfig nearbySelectionConfig = null;
  @XStreamImplicit(itemFieldName = "filterClass")
  protected List<Class<? extends SelectionFilter>> filterClassList = null;

@XStreamAlias("beanInfos")
public class XMLMetaBeanInfos {
  @XStreamAsAttribute
  private String id;
  @XStreamAsAttribute
  private String version;
  @XStreamImplicit
  private List<XMLMetaValidator> validators;
  @XStreamImplicit
  private List<XMLMetaBean> beans;
  @XStreamOmitField
  private Map<String, XMLMetaBean> beanLookup;
  @XStreamOmitField
  private Map<String, XMLMetaValidator> validationLookup;