[jboss-cvs] jboss-serialization/src/org/jboss/serial/objectmetamodel ...

[Clebert S. <csu...@jb...>]

  User: csuconic
  Date: 05/09/25 17:42:50

  Added:       src/org/jboss/serial/objectmetamodel  FieldsContainer.java
  Log:
  JBSER-25 Implementation of PutField and GetField what will fix BigDecimals
  
  Revision  Changes    Path
  1.1      date: 2005/09/25 21:42:50;  author: csuconic;  state: Exp;jboss-serialization/src/org/jboss/serial/objectmetamodel/FieldsContainer.java
  
  Index: FieldsContainer.java
  ===================================================================
  /*
   * JBoss, Home of Professional Open Source
   *
   * Distributable under LGPL license.
   * See terms of license at gnu.org.
   */
  
  package org.jboss.serial.objectmetamodel;
  
  import org.jboss.serial.classmetamodel.ClassMetaData;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.io.*;
  
  /**
   * $Id: FieldsContainer.java,v 1.1 2005/09/25 21:42:50 csuconic Exp $
   *
   * @author <a href="mailto:tcl...@jb...">Clebert Suconic</a>
   */
  public class FieldsContainer  {
  
      ClassMetaData metaData;
  
      protected HashMap fields = new HashMap();
  
  
      /** both {@link org.jboss.serial.persister.RegularObjectPersister) and writeMyself need to produce the same binary compatible output while
       * it's not required by RegularObjectPersister to create an intermediate HashMap to read its fields. Becuase of that we
       * have opted in keep static methods on FieldsContainer that will expose low level persistent operations */
      public static void writeNumberOfFields(ObjectOutput out, int fields) throws IOException
      {
          out.writeInt(fields);
      }
  
      /** both {@link org.jboss.serial.persister.RegularObjectPersister) and writeMyself need to produce the same binary compatible output while
       * it's not required by RegularObjectPersister to create an intermediate HashMap to read its fields. Becuase of that we
       * have opted in keep static methods on FieldsContainer that will expose low level persistent operations */
      public static void writeField(ObjectOutput out, Map.Entry entry) throws IOException
      {
          out.writeUTF((String)entry.getKey());
          out.writeObject(entry.getValue());
      }
  
      public void writeMyself(ObjectOutput output) throws IOException
      {
          writeNumberOfFields(output,fields.size());
          Iterator iter = fields.entrySet().iterator();
          while (iter.hasNext())
          {
              Map.Entry entry = (Map.Entry)iter.next();
              writeField(output,entry);
          }
      }
  
  
      /** both {@link org.jboss.serial.persister.RegularObjectPersister) and readMyself need to produce the same binary compatible output while
       * it's not required by RegularObjectPersister to create an intermediate HashMap to read its fields. Becuase of that we
       * have opted in keep static methods on FieldsContainer that will expose low level persistent operations */
      public static int readNumberOfFields(ObjectInput input) throws IOException
      {
          return input.readInt();
      }
  
  
      public static Map.Entry readField(ObjectInput input) throws IOException,ClassNotFoundException
      {
          String name = input.readUTF();
          Object value = input.readObject();
  
          return new EntryImpl(name,value);
      }
  
      public static class EntryImpl implements Map.Entry
      {
          private Object key;
          private Object value;
  
          public EntryImpl(Object key, Object value)
          {
              this.key=key;
              this.value=value;
          }
          public Object getKey() {
              return key;
          }
  
          public Object getValue() {
              return value;
          }
  
          public Object setValue(Object value) {
              throw new RuntimeException("method not supported");
          }
      }
  
      public void readMyself(ObjectInput input) throws IOException,ClassNotFoundException
      {
          fields.clear();
          int numberOfFields = readNumberOfFields(input);
  
          for (int i=0;i<numberOfFields;i++)
          {
              Map.Entry entry = readField(input);
              setField((String)entry.getKey(),entry.getValue());
          }
      }
  
  
      protected void setField(String name, Object value)
      {
          fields.put(name,value);
      }
  
  
      public FieldsContainer(ClassMetaData metaData)
      {
          this.metaData=metaData;
      }
  
  
      public ObjectInputStream.GetField createGet()
      {
          return new GetFieldImpl();
      }
  
      public ObjectOutputStream.PutField createPut()
      {
          return new PutFieldImpl();
      }
  
      class GetFieldImpl extends ObjectInputStream.GetField
      {
          public GetFieldImpl() {
              super();
          }
          public ObjectStreamClass getObjectStreamClass()
          {
              return ObjectStreamClass.lookup(metaData.getClazz());
          }
  
          public boolean defaulted(String name) throws IOException
          {
              return fields.get(name)==null;
          }
  
         public boolean get(String name, boolean val)
             throws IOException
         {
             Boolean ret = (Boolean)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             } else
             {
                 return ret.booleanValue();
             }
         }
  
         public byte get(String name, byte val) throws IOException
         {
             Byte ret = (Byte)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.byteValue();
             }
  
         }
  
         public char get(String name, char val) throws IOException
         {
             Character ret = (Character)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.charValue();
             }
         }
  
         public short get(String name, short val) throws IOException
         {
             Short ret = (Short)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.shortValue();
             }
         }
  
         public int get(String name, int val) throws IOException
         {
             Integer ret = (Integer)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.intValue();
             }
         }
  
         public long get(String name, long val) throws IOException
         {
             Long ret = (Long)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.longValue();
             }
         }
  
         public float get(String name, float val) throws IOException
         {
             Float ret = (Float)fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.floatValue();
             }
         }
  
         public double get(String name, double val) throws IOException
         {
             Double ret = (Double) fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret.doubleValue();
             }
         }
  
         public Object get(String name, Object val) throws IOException
         {
             Object ret = fields.get(name);
  
             if (ret==null)
             {
                 return val;
             }
             else
             {
                 return ret;
             }
         }
      }
  
      class PutFieldImpl extends ObjectOutputStream.PutField
      {
          public void put(String name, boolean val)
          {
              setField(name,new Boolean(val));
          }
  
          public void put(String name, byte val)
          {
              setField(name,new Byte(val));
          }
  
          public void put(String name, char val)
          {
              setField(name,new Character(val));
          }
  
          public void put(String name, short val)
          {
              setField(name,new Short(val));
          }
  
          public void put(String name, int val)
          {
              setField(name,new Integer(val));
          }
  
          public void put(String name, long val)
          {
              setField(name,new Long(val));
          }
  
          public void put(String name, float val)
          {
              setField(name, new Float(val));
          }
  
          public void put(String name, double val)
          {
              setField(name,new Double(val));
          }
  
          public void put(String name, Object val)
          {
              setField(name, val);
          }
  
          public void write(ObjectOutput out) throws IOException
          {
              writeMyself(out);
          }
      }
  
  }