/**
   * @param writer
   * @param includeHistory
   * @param session
   * @throws DataAccessException
   * @throws HibernateException
   */
  private void writeObjects(
      final Writer writer,
      final boolean includeHistory,
      final Session session,
      final boolean preserveIds)
      throws DataAccessException, HibernateException {
    // Container für die Objekte
    final List<Object> all = new ArrayList<Object>();
    final XStream stream = initXStream(session, true);
    final XStream defaultXStream = initXStream(session, false);

    session.flush();
    // Alles laden
    List<?> list = session.createQuery("select o from java.lang.Object o").setReadOnly(true).list();
    list = (List<?>) CollectionUtils.select(list, PredicateUtils.uniquePredicate());
    final int size = list.size();
    log.info("Writing " + size + " objects");
    for (final Iterator<?> it = list.iterator(); it.hasNext(); ) {
      final Object obj = it.next();
      if (log.isDebugEnabled()) {
        log.debug("loaded object " + obj);
      }
      if ((obj instanceof HistoryEntry || obj instanceof PropertyDelta)
          && includeHistory == false) {
        continue;
      }
      Hibernate.initialize(obj);
      final Class<?> targetClass = HibernateProxyHelper.getClassWithoutInitializingProxy(obj);
      final ClassMetadata classMetadata = session.getSessionFactory().getClassMetadata(targetClass);
      if (classMetadata == null) {
        log.fatal("Can't init " + obj + " of type " + targetClass);
        continue;
      }
      // initalisierung des Objekts...
      defaultXStream.marshal(obj, new CompactWriter(new NullWriter()));

      if (preserveIds == false) {
        // Nun kann die ID gelöscht werden
        classMetadata.setIdentifier(obj, null, EntityMode.POJO);
      }
      if (log.isDebugEnabled()) {
        log.debug("loading evicted object " + obj);
      }
      if (this.ignoreFromTopLevelListing.contains(targetClass) == false) {
        all.add(obj);
      }
    }
    // und schreiben
    try {
      writer.write("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n");
    } catch (final IOException ex) {
      // ignore, will fail on stream.marshal()
    }
    log.info("Wrote " + all.size() + " objects");
    final MarshallingStrategy marshallingStrategy = new ProxyIdRefMarshallingStrategy();
    stream.setMarshallingStrategy(marshallingStrategy);
    stream.marshal(all, new PrettyPrintWriter(writer));
  }
  /** Performs tasks to resolve the lazy instantiation. */
  private synchronized void init() {
    if (!initialized) {
      // Mimic the behavior of XStream's JVM class
      String vendor = System.getProperty("java.vm.vendor");
      float version = 1.3f;
      try {
        version = Float.parseFloat(System.getProperty("java.version").substring(0, 3));
      } catch (NumberFormatException nfe) {
        // Keep the default
      }
      Class unsafe = null;
      try {
        unsafe = Class.forName("sun.misc.Unsafe", false, getClass().getClassLoader());
      } catch (ClassNotFoundException cnfe) {
        // Keep the default
      }
      ReflectionProvider reflectionProvider = null;
      if ((vendor.contains("Sun")
              || vendor.contains("Oracle")
              || vendor.contains("Apple")
              || vendor.contains("Hewlett-Packard")
              || vendor.contains("IBM")
              || vendor.contains("Blackdown"))
          && version >= 1.4f
          && unsafe != null) {
        try {
          reflectionProvider =
              (ReflectionProvider)
                  Class.forName(
                          "com.thoughtworks.xstream.converters.reflection.Sun14ReflectionProvider",
                          false,
                          getClass().getClassLoader())
                      .newInstance();
        } catch (InstantiationException ie) {
          reflectionProvider = new PureJavaReflectionProvider();
        } catch (IllegalAccessException iae) {
          reflectionProvider = new PureJavaReflectionProvider();
        } catch (ClassNotFoundException cnfe) {
          reflectionProvider = new PureJavaReflectionProvider();
        }
      } else {
        reflectionProvider = new PureJavaReflectionProvider();
      }
      HierarchicalStreamDriver driver = new DomDriver();

      xs = new XStream(reflectionProvider, driver);
      xs.setMarshallingStrategy(new LockssReferenceByXPathMarshallingStrategy(lockssContext));
      xs.registerConverter(new LockssDateConverter());
      initialized = true;
    }
  }
 /** @return */
 private XStream initXStream(final Session session, final boolean nullifyPk) {
   final XStream xstream =
       new XStream() {
         @Override
         protected MapperWrapper wrapMapper(final MapperWrapper next) {
           return new HibernateMapper(new HibernateCollectionsMapper(next));
         }
       };
   // Converter für die Hibernate-Collections
   xstream.registerConverter(new HibernateCollectionConverter(xstream.getConverterLookup()));
   xstream.registerConverter(
       new HibernateProxyConverter(
           xstream.getMapper(), new PureJavaReflectionProvider(), xstream.getConverterLookup()),
       XStream.PRIORITY_VERY_HIGH);
   xstream.setMarshallingStrategy(
       new XStreamMarshallingStrategy(XStreamMarshallingStrategy.RELATIVE));
   init(xstream);
   return xstream;
 }
  @Test
  public void synchronizedCollectionText()
      throws NoSuchFieldException, SecurityException, IllegalArgumentException,
          IllegalAccessException {
    Map<String, String> map = Collections.synchronizedMap(new LinkedHashMap<String, String>());
    map.put("hello", "world");
    map.put("second", "value");

    XStream xs = new XStream();
    xs.setMarshallingStrategy(
        new MigratingMarshallingStrategy(new MigrationManager("com.t3.", true)));

    System.out.println(xs.toXML(map));
    Map<String, String> map2 = (Map<String, String>) xs.fromXML(xs.toXML(map));

    Assert.assertEquals(map, map2);
    Assert.assertEquals(map.getClass(), map2.getClass());

    // make shure that is map is of the same type
    Field f = map.getClass().getDeclaredField("m");
    f.setAccessible(true);
    Assert.assertEquals(f.get(map).getClass(), LinkedHashMap.class);
    Assert.assertEquals(f.get(map2).getClass(), LinkedHashMap.class);
  }
Example #5
0
  private Pair<String, Object> parseEntry(Node node) {
    NodeList nl = node.getChildNodes();
    String name = null;
    Object value = null;
    for (int i = 0; i < nl.getLength(); i++) {
      Node ii = nl.item(i);

      ii = resolve(ii);

      System.out.println(" entry, name <" + ii.getNodeName() + ">");

      if (ii.getNodeName().equals("field.core.dispatch.iVisualElement_-VisualElementProperty")) {

        NodeList childNodes = ii.getChildNodes();
        for (int j = 0; j < childNodes.getLength(); j++) {

          Node cn = childNodes.item(j);
          cn = resolve(cn);

          System.out.println(" property <" + cn.getNodeName() + ">");
          if (cn.getNodeName().equals("name")) {
            name = cn.getTextContent();
            System.out.println(" name is <" + name + ">");
          }
        }
      } else if (ii.getNodeName().equals("string")) {
        value = ii.getTextContent().trim();
      } else if (ii.getNodeName().equals("float")) {
        value = Float.parseFloat(ii.getTextContent().trim());
      } else if (ii.getNodeName().equals("double")) {
        value = Double.parseDouble(ii.getTextContent().trim());
      } else {
; // System.out.println(" node is xml <" + loadProperties + ">");

        if (loadProperties) {
          try {
            String xml = nodeToString(ii);
            if (xml.trim().length() == 0) continue;
            if (xml.contains("reference=")) continue;
            if (xml.contains("id=")) continue;

            ; // System.out.println(" xml is <" + xml + ">");
            xml = "<object-stream>" + xml + "</object-stream>";

            XStream stream = new XStream(new Sun14ReflectionProvider());
            stream.registerConverter(new ChannelSerializer());
            stream.registerConverter(new FloatBufferSerializer());
            stream.registerConverter(new MarkerSerializer(stream.getClassMapper()));
            stream.setMarshallingStrategy(new ReferenceByIdMarshallingStrategy());
            Object o = stream.createObjectInputStream(new StringReader(xml)).readObject();
            value = o;
            ; // System.out.println(" -- loaded <" + value + ">");
          } catch (Throwable t) {
            System.out.println(
                " trouble loading contents of <" + ii.getNodeName() + "> continuing on");
          }
        }
      }
    }

    //		System.out.println(" got <" + name + " = " + value + ">");

    if (name == null) return null;
    if (value == null) return null;
    else return new Pair<String, Object>(name, value);
  }
  /**
   * 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);
    }
  }