コード例 #1
0
 public void writeHiddenClass(
     TreeMapConverter mapConverter, HierarchicalStreamWriter writer, MarshallingContext context) {
   if (Snapshot.getLocal().getFieldSetFromId(id) != null) {
     writer.startNode(nodeName);
     writer.addAttribute(XMLConstants.ID_ATTRIBUTE, id.toString());
     writer.addAttribute(XMLConstants.FIELDSET_ATTRIBUTE, "true");
     mapConverter.marshal(Snapshot.getLocal().getFieldSetFromId(id), writer, context);
     writer.endNode();
   }
 }
コード例 #2
0
  // ----------------------------------------------------------
  public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
    if (source instanceof AbstractPersistentMap) {
      throw new IllegalArgumentException(
          "You cannot store an object that contains a reference to a "
              + source.getClass().getSimpleName());
    }
    writer.addAttribute(XMLConstants.FIELDSET_ATTRIBUTE, "true");
    Map<String, Object> fields = objectToFieldMap(source);
    // BUG: The persistence store will attempt to persist an inner class.
    // This is the same as storing an object that references the Application
    // class
    if (fields.containsKey("this$0")) {
      throw new IllegalArgumentException(
          "The class "
              + source.getClass().getName()
              + " cannot be persisted because the definition of this class is contained within the "
              + fields.get("this$0").getClass().getName()
              + " class.  Move "
              + source.getClass().getName()
              + " to its own JAVA file.");
    }
    checkFields(source.getClass().getName(), fields);
    UUID id = Snapshot.lookupId(source, true);

    writer.addAttribute(XMLConstants.ID_ATTRIBUTE, id.toString());

    Map<String, Object> updatedFieldSets =
        generateUpdatedFieldSet(Snapshot.getLocal(), Snapshot.getNewest(), source, fields);
    List<String> nulledKeys = new ArrayList<String>();
    for (String key : updatedFieldSets.keySet()) {
      if (updatedFieldSets.get(key) instanceof NullableClass) {
        NullableClass nClass = (NullableClass) updatedFieldSets.get(key);
        nClass.writeHiddenClass(mapConverter, writer, context);
        // updatedFieldSets.remove( key );
        nulledKeys.add(key);
      }
    }
    for (String key : nulledKeys) updatedFieldSets.remove(key);
    restoreObjectFromFieldMap(source, updatedFieldSets);
    Snapshot.getLocal().resolveObject(id, source, updatedFieldSets);
    mapConverter.marshal(updatedFieldSets, writer, context);
  }
コード例 #3
0
  // ----------------------------------------------------------
  public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
    //        Object current = context.currentObject();
    Object result = getInstance(context);
    //        Object result = null;
    if (top == true && key != null && cache != null) {
      // This is simply to prevent infinite recursion when you get an
      // object out of the store that references this object. This stored
      // object will be overwritten when everything is finished.
      cache.put(key, new StoredObject(key, "ALIAS", result, Snapshot.getLocal(), Long.MAX_VALUE));
      top = false;
    }
    Map<String, Object> fields = null;
    UUID id = null;
    if (reader.getAttribute(XMLConstants.FIELDSET_ATTRIBUTE) != null) {
      String objId = reader.getAttribute(XMLConstants.ID_ATTRIBUTE);
      id = UUID.fromString(objId);
      @SuppressWarnings("unchecked")
      Map<String, Object> realFields =
          (Map<String, Object>) mapConverter.unmarshal(reader, context);
      fields = realFields;
    } else {
      result = super.unmarshal(reader, context);
      if (result instanceof TreeMap && !TreeMap.class.isAssignableFrom(context.getRequiredType())) {
        @SuppressWarnings("unchecked")
        Map<String, Object> realFields = (Map<String, Object>) result;
        fields = realFields;
      }
    }

    if (fields != null) {
      try {
        Method initFieldsMethod = result.getClass().getMethod("initializeFields", (Class<?>) null);
        initFieldsMethod.invoke(result, (Object[]) null);
      } catch (Exception e) {
        // its ok if this doesnt exist
      }
      //            result = reflectionProvider.newInstance( context.getRequiredType() );
      restoreObjectFromFieldMap(result, fields); /*
                                                               * && pjProvider
                                                               * != null
                                                               */
      //            {
      //                try
      //                {
      //                    Method initFieldsMethod = result.getClass()
      //                        .getMethod( "initializeFields", (Class<?>)null );
      //                    initFieldsMethod.invoke( result, (Object[])null );
      //                }
      //                catch ( Exception e )
      //                {
      //                    try
      //                    {
      //                        Constructor<?> defaultConst = result.getClass()
      //                            .getConstructor();
      //                        Object newResult = defaultConst.newInstance();
      //                        restoreObjectFromFieldMap( newResult, fields );
      //                        result = newResult;
      //
      //                    }
      //                    catch ( SecurityException e1 )
      //                    {
      //                        System.err.println( "You made your default constructor for "
      //                            + result.getClass().getName()
      //                            + " private.  If you would like it to be used"
      //                            + " by the persistence library please make it public" );
      //                    }
      //                    catch ( NoSuchMethodException e2 )
      //                    {
      //                        System.err.println( "The shared object \""
      //                            + result.getClass().getName()
      //                            + "\" you have loaded did not "
      //                            + "contain all of the fields present in your original object.  "
      //                            + "We were also unable to find a method with the signature
      // \"public "
      //                            + "void initializeFields()\" or the "
      //                            + "default constructor \"public "
      //                            + result.getClass().getName()
      //                            + "()\".  If you have made assumptions "
      //                            + "about the state of certain fields in your "
      //                            + result.getClass().getName()
      //                            + " Object please provide one of these methods to initialize the
      // fields "
      //                            + "not present in the datastore." );
      //                    }
      //                    catch ( Exception e3 )
      //                    {
      //                        System.err.println( "An exception occured when initializing your
      // object with the default constructor." );
      //                    }
      //
      //                }
      //            }

      if (result != null) {
        Snapshot.getLocal().resolveObject(id, result, fields);
      }
    }

    return result;
  }