Example #1
0
  public static void registerMapping(XStream xstream) {
    // In the XML the class is represented as a page - tag
    xstream.alias("page", CPNPage.class);

    xstream.useAttributeFor(CPNPage.class, "idattri");
    xstream.aliasAttribute(CPNPage.class, "idattri", "id");

    // In order not to display the places / transitions / arcs tag, but simply show
    // the page tags one after another.
    xstream.addImplicitCollection(CPNPage.class, "places", CPNPlace.class);
    xstream.addImplicitCollection(CPNPage.class, "transitions", CPNTransition.class);
    xstream.addImplicitCollection(CPNPage.class, "arcs", CPNArc.class);

    // Sometimes XStream cannot translate elements into a XML structure.
    // Therefore exists the possibility to create and register a converter for that element.
    xstream.registerConverter(new CPNTextConverter());

    // These instance variables are not needed for the mapping, that's why they are excluded
    xstream.omitField(CPNPage.class, "arcRelation");
    xstream.omitField(CPNPage.class, "nodePositions");

    // Giving all fields a concrete name for the XML
    xstream.aliasField("Aux", CPNPage.class, "auxtag");
    xstream.aliasField("group", CPNPage.class, "grouptag");
    xstream.aliasField("vguidelines", CPNPage.class, "vguidelines");
    xstream.aliasField("hguidelines", CPNPage.class, "hguidelines");

    CPNPageattr.registerMapping(xstream);
    CPNModellingThing.registerMapping(xstream);
    CPNPlace.registerMapping(xstream);
    CPNTransition.registerMapping(xstream);
    CPNArc.registerMapping(xstream);
    CPNLittleProperty.registerMapping(xstream);
  }
 /** @see org.olat.core.configuration.Initializable#init() */
 public void init() {
   mystream = XStreamHelper.createXStreamInstance();
   mystream.alias("versions", VersionsFileImpl.class);
   mystream.alias("revision", RevisionFileImpl.class);
   mystream.omitField(VersionsFileImpl.class, "currentVersion");
   mystream.omitField(VersionsFileImpl.class, "versionFile");
   mystream.omitField(RevisionFileImpl.class, "current");
   mystream.omitField(RevisionFileImpl.class, "container");
   mystream.omitField(RevisionFileImpl.class, "file");
 }
 @Override
 protected void configureXStream(XStream xstream) {
   xstream.omitField(BeanWithId.class, "m_id");
   xstream.alias("entry", PhonebookEntry.class);
   xstream.aliasField("first-name", PhonebookEntry.class, "firstName");
   xstream.aliasField("last-name", PhonebookEntry.class, "lastName");
   xstream.aliasField("contact-information", PhonebookEntry.class, "addressBookEntry");
   xstream.omitField(PhonebookEntry.class, "m_phonebook");
   xstream.omitField(AddressBookEntry.class, "m_useBranchAddress");
   xstream.omitField(AddressBookEntry.class, "m_branchOfficeAddress");
 }
Example #4
0
 public void configure(XStream xStream) {
   xStream.alias("profile", RulesProfile.class);
   xStream.alias("alert", Alert.class);
   xStream.alias("active-rule", ActiveRule.class);
   xStream.aliasField("active-rules", RulesProfile.class, "activeRules");
   xStream.aliasField("default-profile", RulesProfile.class, "defaultProfile");
   xStream.omitField(RulesProfile.class, "id");
   xStream.omitField(RulesProfile.class, "projects");
   xStream.registerConverter(getActiveRuleConverter());
   xStream.registerConverter(getAlertsConverter());
 }
  public XmlProjectDescriptorSerializer(boolean postProcess) {
    xstream = new XStream(new DomDriver());
    xstream.ignoreUnknownElements();
    xstream.omitField(ProjectDescriptor.class, "id"); // This field was deprecated
    xstream.omitField(ProjectDescriptor.class, "log");
    xstream.omitField(ProjectDescriptor.class, "classLoader");
    xstream.omitField(ProjectDescriptor.class, "projectFolder");
    xstream.omitField(Module.class, "properties"); // properties doesn't supported by rules.xml
    xstream.omitField(Module.class, "wildcardName"); // runtime properties
    xstream.omitField(Module.class, "wildcardRulesRootPath"); // runtime properties
    xstream.omitField(Module.class, "project"); // runtime properties

    xstream.setMode(XStream.NO_REFERENCES);

    xstream.aliasType(PROJECT_DESCRIPTOR_TAG, ProjectDescriptor.class);
    xstream.aliasType(MODULE_TAG, Module.class);
    xstream.aliasType(DEPENDENCY_TAG, ProjectDependencyDescriptor.class);
    xstream.aliasType(PATH_TAG, PathEntry.class);
    xstream.aliasType(PROPERTY_TAG, Property.class);
    xstream.aliasField(
        PROPERTIES_FILE_NAME_PATTERN, ProjectDescriptor.class, "propertiesFileNamePattern");
    xstream.aliasField(
        PROPERTIES_FILE_NAME_PROCESSOR, ProjectDescriptor.class, "propertiesFileNameProcessor");
    xstream.addDefaultImplementation(HashSet.class, Collection.class);
    xstream.alias("value", String.class);

    xstream.useAttributeFor(PathEntry.class, "path");
    xstream.aliasField("rules-root", Module.class, "rulesRootPath");
    xstream.aliasField(METHOD_FILTER_TAG, Module.class, "methodFilter");
    xstream.registerConverter(new StringValueConverter());

    this.postProcess = postProcess;
  }
 public String toXML(boolean omitId) {
   XStream xs = new XStream();
   xs.alias("PedidoDeAbastecimiento", PedidoAbastecimientoVO.class);
   xs.alias("ocAsociada", OrdenDeCompraVO.class);
   xs.alias("Rodamiento", RodamientoVO.class);
   xs.alias("Proveedor", ProveedorVO.class);
   if (omitId) {
     xs.omitField(OrdenDeCompraVO.class, "idODV");
     xs.omitField(ProveedorVO.class, "id");
     xs.omitField(RodamientoVO.class, "id");
   }
   xs.omitField(PedidoAbastecimientoVO.class, "cantidadPendiente");
   xs.omitField(PedidoAbastecimientoVO.class, "ocAsociada");
   return xs.toXML(this);
 }
Example #7
0
  /**
   * @param xstreamObject not null
   * @param jarFile not null
   * @param packageFilter a package name to filter.
   */
  private void addAlias(XStream xstreamObject, File jarFile, String packageFilter) {
    JarInputStream jarStream = null;
    try {
      jarStream = new JarInputStream(new FileInputStream(jarFile));
      JarEntry jarEntry = jarStream.getNextJarEntry();
      while (jarEntry != null) {
        if (jarEntry.getName().toLowerCase(Locale.ENGLISH).endsWith(".class")) {
          String name = jarEntry.getName().substring(0, jarEntry.getName().indexOf("."));
          name = name.replaceAll("/", "\\.");

          if (name.indexOf(packageFilter) != -1) {
            try {
              Class<?> clazz = ClassUtils.getClass(name);
              String alias = StringUtils.lowercaseFirstLetter(ClassUtils.getShortClassName(clazz));
              xstreamObject.alias(alias, clazz);
              if (!clazz.equals(Model.class)) {
                xstreamObject.omitField(clazz, "modelEncoding"); // unnecessary field
              }
            } catch (ClassNotFoundException e) {
              e.printStackTrace();
            }
          }
        }

        jarStream.closeEntry();
        jarEntry = jarStream.getNextJarEntry();
      }
    } catch (IOException e) {
      if (getLog().isDebugEnabled()) {
        getLog().debug("IOException: " + e.getMessage(), e);
      }
    } finally {
      IOUtil.close(jarStream);
    }
  }
  private XStream createXStream() {
    XStream xstream = new XStream(new DomDriver());
    xstream.registerConverter(new TileConverter());
    //        xstream.registerConverter(new PointConverter());
    xstream.registerConverter(new SceneryConverter());
    xstream.registerConverter(new SpriteConverter());
    xstream.registerConverter(new DrawnTileConverter());
    xstream.registerConverter(new SceneryBagConverter());
    xstream.registerConverter(new LayerConverter());
    xstream.registerConverter(new LayerArrayConverter());

    xstream.alias("drawntile", DrawnTile.class);

    xstream.alias("point", Point.class);
    xstream.useAttributeFor("name", String.class);
    xstream.alias("project", Project.class);
    xstream.omitField(Project.class, "tileSetBag");
    xstream.omitField(Project.class, "path");
    return xstream;
  }
Example #9
0
  /** Returns a StringRepresentation with the status of the running threads in the thread pool. */
  private void handleProgress(Request req, Response resp, ArrayList<GWCTaskStatus> taskList)
      throws RestletException {

    Object[] tasks = taskList.toArray();

    StringBuilder strBld = new StringBuilder();
    strBld.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
    strBld.append("<Tasks>");

    XStream xs = new XStream();
    xs.omitField(GWCTask.class, "parsedType");
    xs.omitField(GWCTask.class, "state");
    xs.omitField(GWCTask.class, "sharedThreadCount");
    xs.omitField(GWCTask.class, "groupStartTime");
    xs.omitField(GWCTask.class, "storageBroker");

    xs.alias("GWCTaskStatus", GWCTaskStatus.class);

    for (int i = 0; i < tasks.length; i++) {
      GWCTaskStatus taskStatus = (GWCTaskStatus) tasks[i];
      Iterator<Entry<Long, GWCTask>> iter = seeder.getRunningTasksIterator();

      while (iter.hasNext()) {
        Entry<Long, GWCTask> entry = iter.next();
        GWCTask task = entry.getValue();
        if (task.getDbId() == taskStatus.getDbId()) {
          taskStatus.setTaskId(task.getTaskId());
          taskStatus.setThreadRunning(true);
          taskStatus.setTilesDone(task.getTilesDone());
          taskStatus.setTilesTotal(task.getTilesTotal());
          taskStatus.setTimeSpent(task.getTimeSpent());
          taskStatus.setTimeRemaing(task.getTimeRemaining());
        }
      }
      String task_xml = xs.toXML(taskStatus);
      strBld.append(task_xml);
    }

    strBld.append("</Tasks>");
    resp.setEntity(strBld.toString(), MediaType.TEXT_XML);
  }
  public void fromXML(String textReceived, boolean omitId) {
    XStream xs = new XStream();
    xs.alias("PedidoDeAbastecimiento", PedidoAbastecimientoVO.class);
    xs.alias("ocAsociada", OrdenDeCompraVO.class);
    xs.alias("Rodamiento", RodamientoVO.class);
    xs.alias("Proveedor", ProveedorVO.class);
    if (omitId) {
      xs.omitField(OrdenDeCompraVO.class, "idODV");
      xs.omitField(ProveedorVO.class, "id");
      xs.omitField(RodamientoVO.class, "id");
    }
    xs.omitField(PedidoAbastecimientoVO.class, "cantidadPendiente");
    xs.omitField(PedidoAbastecimientoVO.class, "ocAsociada");

    PedidoAbastecimientoVO pavo = (PedidoAbastecimientoVO) xs.fromXML(textReceived);
    this.setIdPedido(pavo.getIdPedido());
    this.setRodamiento(pavo.getRodamiento());
    this.setOcAsociada(pavo.getOcAsociada());
    this.setProveedor(pavo.getProveedor());
    this.setCantidadPedida(pavo.getCantidadPedida());
    this.setCantidadPendiente(pavo.getCantidadPendiente());
  }
Example #11
0
  protected XStream createXStream(ClassResolver resolver, ClassLoader classLoader) {
    if (xstreamDriver != null) {
      xstream = new XStream(xstreamDriver);
    } else {
      xstream = new XStream();
    }

    if (mode != null) {
      xstream.setMode(getModeFromString(mode));
    }

    ClassLoader xstreamLoader = xstream.getClassLoader();
    if (classLoader != null && xstreamLoader instanceof CompositeClassLoader) {
      ((CompositeClassLoader) xstreamLoader).add(classLoader);
    }

    try {
      if (this.implicitCollections != null) {
        for (Entry<String, String[]> entry : this.implicitCollections.entrySet()) {
          for (String name : entry.getValue()) {
            xstream.addImplicitCollection(resolver.resolveMandatoryClass(entry.getKey()), name);
          }
        }
      }

      if (this.aliases != null) {
        for (Entry<String, String> entry : this.aliases.entrySet()) {
          xstream.alias(entry.getKey(), resolver.resolveMandatoryClass(entry.getValue()));
          // It can turn the auto-detection mode off
          xstream.processAnnotations(resolver.resolveMandatoryClass(entry.getValue()));
        }
      }

      if (this.omitFields != null) {
        for (Entry<String, String[]> entry : this.omitFields.entrySet()) {
          for (String name : entry.getValue()) {
            xstream.omitField(resolver.resolveMandatoryClass(entry.getKey()), name);
          }
        }
      }

      if (this.converters != null) {
        for (String name : this.converters) {
          Class<Converter> converterClass = resolver.resolveMandatoryClass(name, Converter.class);
          Converter converter;

          Constructor<Converter> con = null;
          try {
            con = converterClass.getDeclaredConstructor(new Class[] {XStream.class});
          } catch (Exception e) {
            // swallow as we null check in a moment.
          }
          if (con != null) {
            converter = con.newInstance(xstream);
          } else {
            converter = converterClass.newInstance();
            try {
              Method method = converterClass.getMethod("setXStream", new Class[] {XStream.class});
              if (method != null) {
                ObjectHelper.invokeMethod(method, converter, xstream);
              }
            } catch (Throwable e) {
              // swallow, as it just means the user never add an XStream setter, which is optional
            }
          }

          xstream.registerConverter(converter);
        }
      }

      addDefaultPermissions(xstream);
      if (this.permissions != null) {
        // permissions ::= pterm (',' pterm)*   # consits of one or more terms
        // pterm       ::= aod? wterm           # each term preceded by an optional sign
        // aod         ::= '+' | '-'            # indicates allow or deny where allow if omitted
        // wterm       ::= a class name with optional wildcard characters
        addPermissions(xstream, permissions);
      }
    } catch (Exception e) {
      throw new RuntimeException("Unable to build XStream instance", e);
    }

    return xstream;
  }
Example #12
0
  private void ustawAliasy(XStream _xstream) {
    _xstream.alias("Sygnał", Sygnal.class);

    // _xstream.aliasField("Parametry", Sygnal.class, "sygnal_parametry");

    _xstream.aliasField("typSygnału", Sygnal.class, "typ");
    _xstream.aliasField("amplituda", Sygnal.class, "A");
    _xstream.aliasField("czasPoczątkowy", Sygnal.class, "t1");
    _xstream.aliasField("czasTrwania", Sygnal.class, "d");
    _xstream.aliasField("okresPodstawowy", Sygnal.class, "T");
    _xstream.aliasField("współczynnikWypełnienia", Sygnal.class, "kw");
    _xstream.aliasField("punkty", Sygnal.class, "punktyY_wykres");
    _xstream.aliasField("kroczek", Sygnal.class, "kroczek");
    _xstream.aliasField("krok", Sygnal.class, "krok");

    if (this.sygnal.getrodzaj() == rodzaj_sygnalu.CIAGLY) {
      _xstream.omitField(Sygnal.class, "ts");
      _xstream.omitField(Sygnal.class, "krok");
      _xstream.omitField(Sygnal.class, "kroczek");
      _xstream.omitField(Sygnal.class, "punktyY_wykres");
      _xstream.omitField(Sygnal.class, "punktyY_probkowanie");
      _xstream.omitField(Sygnal.class, "punktyY_kwantyzacja");
      _xstream.omitField(Sygnal.class, "poziom_kwantyzacji_krok");
      _xstream.omitField(Sygnal.class, "poziomy_kwantyzacji");
      if (this.sygnal.gettyp() != 9 || this.sygnal.gettyp() != 10) {
        _xstream.omitField(Sygnal.class, "skok");
      }
    }

    if (this.sygnal.getrodzaj() == rodzaj_sygnalu.DYSKRETNY) {
      _xstream.omitField(Sygnal.class, "typ");
      _xstream.omitField(Sygnal.class, "A");
      _xstream.omitField(Sygnal.class, "skok");
      _xstream.omitField(Sygnal.class, "kroczek");
      _xstream.omitField(Sygnal.class, "kw");
      _xstream.omitField(Sygnal.class, "ts");
      _xstream.omitField(Sygnal.class, "T");
      _xstream.omitField(Sygnal.class, "punktyY_probkowanie");
      _xstream.omitField(Sygnal.class, "punktyY_kwantyzacja");
      _xstream.omitField(Sygnal.class, "poziom_kwantyzacji_krok");
      _xstream.omitField(Sygnal.class, "poziomy_kwantyzacji");
      if (this.sygnal.gettyp() != 9 || this.sygnal.gettyp() != 10) {
        _xstream.omitField(Sygnal.class, "skok");
      }
    }
  }
  /**
   * Get configured xstream object.
   *
   * @return {@link XStream}
   */
  private static XStream getXStream() {

    final XStream xStream = new XStream(new DomDriver());

    xStream.alias("customer", CustomerEntity.class);
    xStream.omitField(CustomerEntity.class, "orders");
    xStream.omitField(CustomerEntity.class, "address");
    xStream.omitField(CustomerEntity.class, "shops");
    xStream.omitField(CustomerEntity.class, "coupons");
    xStream.alias("wishlist", CustomerWishListEntity.class);
    xStream.alias("customerAv", AttrValueEntityCustomer.class);
    xStream.omitField(AttrValueEntityCustomer.class, "customer");
    xStream.alias("attribute", AttributeEntity.class);
    xStream.omitField(AttributeEntity.class, "etype");
    xStream.omitField(AttributeEntity.class, "attributeGroup");
    xStream.alias("address", AddressEntity.class);
    xStream.alias("customerShop", CustomerShopEntity.class);

    xStream.alias("payment", CustomerOrderPaymentEntity.class);

    xStream.alias("carrier", CarrierEntity.class);
    xStream.omitField(CarrierEntity.class, "carrierSla");
    xStream.omitField(CarrierEntity.class, "shops");
    xStream.alias("carrierSla", CarrierSlaEntity.class);

    xStream.alias("order", CustomerOrderEntity.class);
    xStream.omitField(CustomerOrderEntity.class, "shop");
    xStream.alias("orderLine", CustomerOrderDetEntity.class);
    xStream.omitField(CustomerOrderDetEntity.class, "customerOrder");
    xStream.alias("orderDelivery", CustomerOrderDeliveryEntity.class);
    xStream.omitField(CustomerOrderDeliveryEntity.class, "customerOrder");
    xStream.alias("deliveryLine", CustomerOrderDeliveryDetEntity.class);
    xStream.omitField(CustomerOrderDeliveryDetEntity.class, "delivery");

    xStream.alias("shop", ShopEntity.class);
    xStream.alias("shopurl", ShopUrlEntity.class);

    xStream.alias("pair", Pair.class);
    xStream.alias("orderDto", CustomerOrderDTOImpl.class);
    xStream.alias("orderDeliveryDto", CustomerOrderDeliveryDTOImpl.class);
    xStream.alias("orderLineDto", CustomerOrderDeliveryDetailDTOImpl.class);

    xStream.alias("shopDto", ShopDTOImpl.class);
    xStream.alias("shopAvDto", AttrValueShopDTOImpl.class);

    xStream.alias("inventoryDto", InventoryDTOImpl.class);

    xStream.registerConverter(
        new Converter() {

          @Override
          public void marshal(
              final Object source,
              final HierarchicalStreamWriter writer,
              final MarshallingContext context) {
            if (source == null) {
              writer.setValue("");
            } else {
              GregorianCalendar calendar = new GregorianCalendar();
              calendar.setTime((Date) source);
              try {
                writer.setValue(
                    DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar).toXMLFormat());
              } catch (DatatypeConfigurationException e) {
                writer.setValue("");
              }
            }
          }

          @Override
          public Object unmarshal(
              final HierarchicalStreamReader reader, final UnmarshallingContext context) {
            return null; // not needed
          }

          @Override
          public boolean canConvert(final Class type) {
            return Date.class.isAssignableFrom(type);
          }
        });

    xStream.registerConverter(
        new Converter() {
          @Override
          public void marshal(
              final Object source,
              final HierarchicalStreamWriter writer,
              final MarshallingContext context) {
            if (((AbstractPersistentCollection) source).wasInitialized()) {
              context.convertAnother(new ArrayList((Collection) source));
            }
          }

          @Override
          public Object unmarshal(
              final HierarchicalStreamReader reader, final UnmarshallingContext context) {
            return null; // not needed
          }

          @Override
          public boolean canConvert(final Class type) {
            return PersistentBag.class == type
                || PersistentList.class == type
                || PersistentSet.class == type;
          }
        });

    xStream.setMode(XStream.NO_REFERENCES);

    return xStream;
  }
  /**
   * Configure the XStream instance with this marshaller's bean properties.
   *
   * @param xstream the {@code XStream} instance
   */
  protected void configureXStream(XStream xstream) {
    if (this.converters != null) {
      for (int i = 0; i < this.converters.length; i++) {
        if (this.converters[i] instanceof Converter) {
          xstream.registerConverter((Converter) this.converters[i], i);
        } else if (this.converters[i] instanceof SingleValueConverter) {
          xstream.registerConverter((SingleValueConverter) this.converters[i], i);
        } else {
          throw new IllegalArgumentException(
              "Invalid ConverterMatcher [" + this.converters[i] + "]");
        }
      }
    }

    if (this.marshallingStrategy != null) {
      xstream.setMarshallingStrategy(this.marshallingStrategy);
    }
    if (this.mode != null) {
      xstream.setMode(this.mode);
    }

    try {
      if (this.aliases != null) {
        Map<String, Class<?>> classMap = toClassMap(this.aliases);
        for (Map.Entry<String, Class<?>> entry : classMap.entrySet()) {
          xstream.alias(entry.getKey(), entry.getValue());
        }
      }
      if (this.aliasesByType != null) {
        Map<String, Class<?>> classMap = toClassMap(this.aliasesByType);
        for (Map.Entry<String, Class<?>> entry : classMap.entrySet()) {
          xstream.aliasType(entry.getKey(), entry.getValue());
        }
      }
      if (this.fieldAliases != null) {
        for (Map.Entry<String, String> entry : this.fieldAliases.entrySet()) {
          String alias = entry.getValue();
          String field = entry.getKey();
          int idx = field.lastIndexOf('.');
          if (idx != -1) {
            String className = field.substring(0, idx);
            Class<?> clazz = ClassUtils.forName(className, this.beanClassLoader);
            String fieldName = field.substring(idx + 1);
            xstream.aliasField(alias, clazz, fieldName);
          } else {
            throw new IllegalArgumentException("Field name [" + field + "] does not contain '.'");
          }
        }
      }
    } catch (ClassNotFoundException ex) {
      throw new IllegalStateException("Failed to load specified alias class", ex);
    }

    if (this.useAttributeForTypes != null) {
      for (Class<?> type : this.useAttributeForTypes) {
        xstream.useAttributeFor(type);
      }
    }
    if (this.useAttributeFor != null) {
      for (Map.Entry<?, ?> entry : this.useAttributeFor.entrySet()) {
        if (entry.getKey() instanceof String) {
          if (entry.getValue() instanceof Class) {
            xstream.useAttributeFor((String) entry.getKey(), (Class<?>) entry.getValue());
          } else {
            throw new IllegalArgumentException(
                "'useAttributesFor' takes Map<String, Class> when using a map key of type String");
          }
        } else if (entry.getKey() instanceof Class) {
          Class<?> key = (Class<?>) entry.getKey();
          if (entry.getValue() instanceof String) {
            xstream.useAttributeFor(key, (String) entry.getValue());
          } else if (entry.getValue() instanceof List) {
            @SuppressWarnings("unchecked")
            List<Object> listValue = (List<Object>) entry.getValue();
            for (Object element : listValue) {
              if (element instanceof String) {
                xstream.useAttributeFor(key, (String) element);
              }
            }
          } else {
            throw new IllegalArgumentException(
                "'useAttributesFor' property takes either Map<Class, String> "
                    + "or Map<Class, List<String>> when using a map key of type Class");
          }
        } else {
          throw new IllegalArgumentException(
              "'useAttributesFor' property takes either a map key of type String or Class");
        }
      }
    }

    if (this.implicitCollections != null) {
      for (Map.Entry<Class<?>, String> entry : this.implicitCollections.entrySet()) {
        String[] collectionFields = StringUtils.commaDelimitedListToStringArray(entry.getValue());
        for (String collectionField : collectionFields) {
          xstream.addImplicitCollection(entry.getKey(), collectionField);
        }
      }
    }
    if (this.omittedFields != null) {
      for (Map.Entry<Class<?>, String> entry : this.omittedFields.entrySet()) {
        String[] fields = StringUtils.commaDelimitedListToStringArray(entry.getValue());
        for (String field : fields) {
          xstream.omitField(entry.getKey(), field);
        }
      }
    }

    if (this.annotatedClasses != null) {
      xstream.processAnnotations(this.annotatedClasses);
    }
    if (this.autodetectAnnotations) {
      xstream.autodetectAnnotations(true);
    }
  }