Package org.jboss.serial.persister

Source Code of org.jboss.serial.persister.RegularObjectPersister

/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/

package org.jboss.serial.persister;

import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.lang.reflect.Field;

import org.apache.log4j.Logger;
import org.jboss.serial.classmetamodel.ClassMetaData;
import org.jboss.serial.classmetamodel.ClassMetaDataSlot;
import org.jboss.serial.classmetamodel.ClassMetadataField;
import org.jboss.serial.classmetamodel.FieldsManager;
import org.jboss.serial.classmetamodel.StreamingClass;
import org.jboss.serial.exception.SerializationException;
import org.jboss.serial.objectmetamodel.DataContainerConstants;
import org.jboss.serial.objectmetamodel.ObjectSubstitutionInterface;
import org.jboss.serial.objectmetamodel.ObjectsCache;

/**
* This is the persister of a regular object.
* @author clebert suconic
*/
public class RegularObjectPersister implements Persister
{
  private static final Logger log = Logger.getLogger(RegularObjectPersister.class);
     private static final boolean isDebug = log.isDebugEnabled();

    byte id;

    public byte getId() {
        return id;
    }

    public void setId(byte id) {
        this.id = id;
    }

    public void writeData(ClassMetaData metaData, ObjectOutput out, Object obj, ObjectSubstitutionInterface substitution) throws IOException
    {
        defaultWrite(out, obj, metaData, substitution);
    }

    public static void defaultWrite(ObjectOutput output, Object obj, ClassMetaData metaClass, ObjectSubstitutionInterface substitution) throws IOException
    {
        //data.getCache().putClassMetaData(metaClass);

      ClassMetaDataSlot slots[] = metaClass.getSlots();
     
      if (isDebug)
      {
        log.debug("defaultWrite::" + metaClass.getClassName() + " contains " + slots.length + " slots");
      }
     
      //output.writeInt(slots.length);
     
      for (int slotNr=0;slotNr<slots.length;slotNr++)
      {
          if (isDebug)
          {
            log.debug("defaultWrite:: slot " + slotNr + " NR=" + slots[slotNr].getSlotClass().getName() + " from parentClass=" + metaClass.getClassName());
          }
        if (slots[slotNr].getPrivateMethodWrite()!=null)
        {
          writeSlotWithMethod(slots[slotNr], output, obj, substitution);
        }
        else
        {
          writeSlotWithFields(slots[slotNr],output, obj, substitution);
        }
      }
     
    }

    private static void readSlotWithMethod(ClassMetaDataSlot slot, short[] fieldsKey, ObjectInput input, Object obj, ObjectSubstitutionInterface substitution) throws IOException
    {
      if (isDebug)
      {
        log.debug("readSlotWithMethod slot=" + slot.getSlotClass().getName());
      }
      try {
      slot.getPrivateMethodRead().invoke(obj,new Object[]{new ObjectInputStreamProxy(input,fieldsKey,obj,slot,substitution)});
    } catch (IOException e) {
      throw e;
    } catch (Exception e) {
      IOException io = new IOException (e.getMessage());
      io.initCause(e);
      throw io;
    }
    }
   
    private static void writeSlotWithMethod(ClassMetaDataSlot slot, ObjectOutput out, Object obj, ObjectSubstitutionInterface substitution) throws IOException
    {
      if (isDebug)
      {
        log.debug("writeSlotWithMethod slot=" + slot.getSlotClass().getName());
      }
      try {
      slot.getPrivateMethodWrite().invoke(obj,new Object[]{new ObjectOutputStreamProxy(out,obj,slot,substitution)});
    }
      catch (IOException e)
      {
        throw e;
      }
      catch (Exception e) {
        log.fatal("error",e);
        e.printStackTrace();
      IOException io = new IOException (e.getMessage());
      io.initCause(e);
      throw io;
    }
    }
   
  static void writeSlotWithFields(ClassMetaDataSlot slot,ObjectOutput output, Object obj, ObjectSubstitutionInterface substitution) throws IOException
  {
    ClassMetadataField[] fields = slot.getFields();
    //output.writeShort(fields.length);
   
      if (isDebug)
      {
        log.debug("writeSlotWithFields slot=" + slot.getSlotClass().getName() + " and " + fields.length + " fields");
      }

      for (int fieldNR=0;fieldNR<fields.length;fieldNR++)
    {
      ClassMetadataField field = fields[fieldNR];
      if (isDebug)
      {
        log.debug("writeSlotWithFields FieldNr=" + fieldNR);
      }

        if (field.getField().getType().isPrimitive() && !field.getField().getType().isArray())
        {
          if (isDebug)
          {
            log.debug("writeSlotWithFields slot=" + slot.getSlotClass().getName() + " primitiveField " + fields[fieldNR].getFieldName() + " with object=NULL");
          }
            writeOnPrimitive(output,obj,field);
        }
        else
        {
            //value = field.getField().get(obj);
            Object value = null;
            value = FieldsManager.getFieldsManager().getObject(obj,field);

            if (isDebug)
          {
              if (value==null)
              {
              log.debug("writeSlotWithFields slot=" + slot.getSlotClass().getName() + " objectField " + fields[fieldNR].getFieldName() + " with object=NULL");
              }
              else
              {
              log.debug("writeSlotWithFields slot=" + slot.getSlotClass().getName() + " objectField " + fields[fieldNR].getFieldName() + " with object=" + value.getClass().getName());
              }
          }

           
            //output.writeUTF(field.getFieldName());
            //output.writeByte(DataContainerConstants.OBJECTREF);
            output.writeObject(value);
        }
    }
  }

    private static void writeOnPrimitive(final ObjectOutput out, final Object obj, final ClassMetadataField metaField) throws IOException
    {

      try
      {
          //out.writeUTF(metaField.getFieldName());
          final Field field = metaField.getField();
          final Class clazz = field.getType();
          if (clazz == Integer.TYPE) {
              //out.writeByte(DataContainerConstants.INTEGER);
              out.writeInt(FieldsManager.getFieldsManager().getInt(obj,metaField));
              //out.writeInt(field.getInt(obj));
          } else if (clazz == Byte.TYPE) {
              //out.writeByte(DataContainerConstants.BYTE);
              out.writeByte(FieldsManager.getFieldsManager().getByte(obj,metaField));
              //out.writeByte(field.getByte(obj));
          } else if (clazz == Long.TYPE) {
              //out.writeByte(DataContainerConstants.LONG);
              out.writeLong(FieldsManager.getFieldsManager().getLong(obj,metaField));
              //out.writeLong(field.getLong(obj));
          } else if (clazz == Float.TYPE) {
              //out.writeByte(DataContainerConstants.FLOAT);
              out.writeFloat(FieldsManager.getFieldsManager().getFloat(obj,metaField));
              //out.writeFloat(field.getFloat(obj));
          } else if (clazz == Double.TYPE) {
              //out.writeByte(DataContainerConstants.DOUBLE);
              out.writeDouble(FieldsManager.getFieldsManager().getDouble(obj,metaField));
              //out.writeDouble(field.getDouble(obj));
          } else if (clazz == Short.TYPE) {
              //out.writeByte(DataContainerConstants.SHORT);
              out.writeShort(FieldsManager.getFieldsManager().getShort(obj,metaField));
              //out.writeShort(field.getShort(obj));
          } else if (clazz == Character.TYPE) {
              //out.writeByte(DataContainerConstants.CHARACTER);
              out.writeChar(field.getChar(obj));
          } else if (clazz == Boolean.TYPE) {
              //out.writeByte(DataContainerConstants.BOOLEAN);
              out.writeBoolean(field.getBoolean(obj));
          } else {
              throw new RuntimeException("Unexpected datatype " + clazz.getName());
          }
      }
      catch (IllegalAccessException access)
      {
        IOException io = new IOException (access.getMessage());
        io.initCause(access);
        throw io;
      }
    }

    public Object readData (ClassLoader loader, StreamingClass streaming, ClassMetaData metaData, int referenceId, ObjectsCache cache, ObjectInput input, ObjectSubstitutionInterface substitution) throws IOException
    {
        Object obj = metaData.newInstance();
        cache.putObjectInCacheRead(referenceId,obj);
        return defaultRead(input, obj,streaming,metaData, substitution);

    }

    public static Object defaultRead(ObjectInput input, Object obj, StreamingClass streaming, ClassMetaData metaData, ObjectSubstitutionInterface substitution) throws IOException {

        try
        {

          //final int numberOfSlots = input.readInt();
         
          ClassMetaDataSlot[] slots = metaData.getSlots();
          if (isDebug)
          {
            log.debug("defaultRead::class " + metaData.getClassName() + " contains " + slots.length + " slots");
          }

          for (int slotNR=0;slotNR<slots.length;slotNR++)
          {
            ClassMetaDataSlot slot = metaData.getSlots()[slotNR];

            if (isDebug)
              {
                log.debug("defaultRead::slot[" + slotNR+"]=" + slot.getSlotClass().getName());
              }
               
            if (slot.getPrivateMethodRead()!=null)
            {
              readSlotWithMethod(slot, streaming.getKeyFields()[slotNR], input, obj, substitution);
            }
            else
            {
              readSlotWithFields(streaming.getKeyFields()[slotNR],slot, input, obj);
            }
          }
           

            return obj;
        }
        catch (ClassNotFoundException e)
        {
            throw new SerializationException("Error reading " + obj.getClass().getName(),e);
        }
        /*catch (IllegalAccessException e)
        {
            throw new SerializationException("Error reading " + field.getField().getDeclaringClass().getName() + " field=" + field.getFieldName(),e);
        } */
    }

  static void readSlotWithFields(short fieldsKey[],ClassMetaDataSlot slot, ObjectInput input, Object obj) throws IOException, ClassNotFoundException {
      if (isDebug)
      {
        log.debug("readSlotWithFields slot=" + slot.getSlotClass().getName());
      }
    //final int numberOfFields = input.readShort();
      short numberOfFields = (short)fieldsKey.length;
    for (short i=0;i<numberOfFields;i++)
    {
        //final String fieldName = input.readUTF();
        ClassMetadataField field = slot.getFields()[fieldsKey[i]];
        if (isDebug)
        {
          log.debug("FieldName on Read=" + field.getFieldName());
        }

        //byte dataType = input.readByte();
       
        if (field.getField().getType()==Integer.TYPE)
        {
              FieldsManager.getFieldsManager().setInt(obj,field,input.readInt());
        }
        else
        if (field.getField().getType()==Byte.TYPE)
        {
              FieldsManager.getFieldsManager().setByte(obj,field,input.readByte());
        }
        else
        if (field.getField().getType()==Long.TYPE)
        {
              FieldsManager.getFieldsManager().setLong(obj,field,input.readLong());
        }
        else
        if (field.getField().getType()==Float.TYPE)
        {
              FieldsManager.getFieldsManager().setFloat(obj,field,input.readFloat());
        }
        else
        if (field.getField().getType()==Double.TYPE)
        {
              FieldsManager.getFieldsManager().setDouble(obj,field,input.readDouble());
        }
        else
        if (field.getField().getType()==Short.TYPE)
        {
              FieldsManager.getFieldsManager().setShort(obj,field,input.readShort());
        }
        else
        if (field.getField().getType()==Character.TYPE)
        {
              FieldsManager.getFieldsManager().setCharacter(obj,field,input.readChar());
        }
        else
        if (field.getField().getType()==Boolean.TYPE)
        {
              FieldsManager.getFieldsManager().setBoolean(obj,field,input.readBoolean());
        }
        else
        {
            if (isDebug)
            {
              log.debug("readSlotWithFields slot=" + slot.getSlotClass().getName() + " field=" + field.getFieldName() + "<<-reading Object");
            }
              Object objTmp = input.readObject();
              FieldsManager.getFieldsManager().setObject(obj,field,objTmp);
        }
    }
  }

    public boolean canPersist(Object obj)
  {
    // not implemented
    return false;
  }

}
TOP

Related Classes of org.jboss.serial.persister.RegularObjectPersister

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.