serializationmanager.java

High performance DB query

            return SERIALUID_TIME;
        }

        if (theObject instanceof Timestamp) {
            SerializeTimestamp.serialize(outputBuffer, (Timestamp) theObject);

            return SERIALUID_TIMESTAMP;
        }

        if (theObject instanceof Vector) {
            SerializeList.serialize(outputBuffer, (Vector) theObject);

            return SERIALUID_VECTOR;
        }

        if (theObject instanceof ArrayList) {
            SerializeList.serialize(outputBuffer, (ArrayList) theObject);

            return SERIALUID_ARRAYLIST;
        }

        if (theObject instanceof Hashtable) {
            SerializeMap.serialize(outputBuffer, (Hashtable) theObject);

            return SERIALUID_HASHTABLE;
        }

        if (theObject instanceof HashMap) {
            SerializeMap.serialize(outputBuffer, (HashMap) theObject);

            return SERIALUID_HASHMAP;
        }

        if (theObject instanceof Byte[]) {
            SerializeByteArray.serialize(outputBuffer, (Byte[]) theObject);

            return SERIALUID_BYTEARRAY;
        }

        if (theObject instanceof BitID) {
            ((BitID) theObject).serialize(outputBuffer);

            return SERIALUID_BITID;
        }

        throw new RuntimeException(
            "SerializationManager: Unable to Serialize class:"
            + theObject.getClass().getName());
    }

    /**
     * Method getSerialUID
     * @return
     */
    public static long getSerialUID() {
        StackTraceElement stack[] = new Exception().getStackTrace();
        String parentClass = stack[1].getClassName();

        return getSerialUID(parentClass);
    }

    /**
     * Method getSerialUID
     *
     * @param classname
     * @return
     */
    public static long getSerialUID(String classname) {
        try {
            Class theClass = Class.forName(classname);
            ObjectStreamClass description = ObjectStreamClass.lookup(theClass);

            if (description != null) {
                return description.getSerialVersionUID();
            } else {
                return 0;
            }
        } catch (ClassNotFoundException exception) {
            throw new RuntimeException(
                "SerializationManager: Unable to calculate serialUID for:"
                + classname);
        }
    }

    /**
     * Method registerClass
     * @return
     */
    public static boolean registerClass() {
        StackTraceElement stack[] = new Exception().getStackTrace();
        String parentClass = stack[1].getClassName();

        return registerClass(getSerialUID(parentClass), parentClass);
    }

    /**
     * Method registerClass
     *
     * @param serialUID
     * @return
     */
    public static boolean registerClass(long serialUID) {
        StackTraceElement stack[] = new Exception().getStackTrace();
        String parentClass = stack[1].getClassName();

        return registerClass(serialUID, parentClass);
    }

    /**
     * Method registerClass
     *
     * @param className
     * @return
     */
    public static boolean registerClass(String className) {
        return registerClass(getSerialUID(className), className);
    }

    /**
     * Method registerClass
     *
     * @param serialUID
     * @param className
     * @return
     */
    public static boolean registerClass(long serialUID, String className) {
        if (classes == null) {
            classes = new Hashtable();

            SerializableClasses.doRegistrations();
        }

        try {
            if (Output.debuggingEnabled) {
                logger.debug(new LogMessage(new Object[]{"Registering class:",
                                                         className,
                                                         " with serialUID:",
                                                         String.valueOf(
                                                             serialUID)}));
            }

            Class objectClass = Class.forName(className);
            Class[] args = {Class.forName(
                               "util.network.serialization.GenericByteBuffer")};
            Constructor theConstructor = null;

            theConstructor = objectClass.getConstructor(args);

            classes.put(new Long(serialUID), theConstructor);

            return true;
        } catch (Exception exception) {
            throw new RuntimeException("ClassManager: Unable to register class:"
                                       + className + "(" + serialUID
                                       + "), ERROR:"
                                       + exception.getClass().getName() + ": "
                                       + exception.getMessage());
        }
    }

    /**
     * Method deSerialize
     *
     * @param inputBuffer
     * @return
     */
    public static Payload deSerialize(GenericByteBuffer inputBuffer) {
        long serialUID = inputBuffer.getLong();

        return deSerialize(inputBuffer, serialUID);
    }

    /**
     * Method deSerialize
     *
     * @param inputBuffer
     * @param serialUID
     * @return
     */
    public static Payload deSerialize(GenericByteBuffer inputBuffer,
                                      long serialUID) {
        Payload theObject = null;

        if (serialUID != 0L) {
            Constructor theConstructor =
                (Constructor) classes.get(new Long(serialUID));
            Object[] args = {inputBuffer};

            try {
                theObject = (Payload) theConstructor.newInstance(args);
            } catch (Exception exception) {
                exception.printStackTrace();

                String classname = (theConstructor == null)
                                   ? "null"
                                   : theConstructor.getDeclaringClass().getName();

                throw new RuntimeException(
                    "SerializationManager: Unable to deserialize class:"
                    + serialUID + "(" + classname + "), ERROR:"
                    + exception.getClass().getName() + ": "
                    + exception.getMessage());
            }
        }

        return theObject;
    }

    /**
     * Method deSerializeExtended
     *
     * @param inputBuffer
     * @return
     */
    public static Object deSerializeExtended(GenericByteBuffer inputBuffer) {
        long serialUID = inputBuffer.getLong();

        return deSerializeExtended(inputBuffer, serialUID);
    }

    /**
     * Method deSerializeExtended
     *
     * @param inputBuffer
     * @param serialUID
     * @return
     */
    public static Object deSerializeExtended(GenericByteBuffer inputBuffer,
                                             long serialUID) {
        if ((serialUID < 0) || (serialUID > 255)) {
            return deSerialize(inputBuffer, serialUID);
        }

        switch ((byte) serialUID) {
        case 0:
            return null;
        case SERIALUID_BOOLEAN:
            return SerializeBoolean.deSerialize(inputBuffer);
        case SERIALUID_BYTE:
            return SerializeByte.deSerialize(inputBuffer);
        case SERIALUID_CHARACTER:
            return SerializeCharacter.deSerialize(inputBuffer);
        case SERIALUID_DOUBLE:
            return SerializeDouble.deSerialize(inputBuffer);
        case SERIALUID_FLOAT:
            return SerializeFloat.deSerialize(inputBuffer);
        case SERIALUID_INTEGER:
            return SerializeInteger.deSerialize(inputBuffer);
        case SERIALUID_LONG:
            return SerializeLong.deSerialize(inputBuffer);
        case SERIALUID_SHORT:
            return SerializeShort.deSerialize(inputBuffer);
        case SERIALUID_BIGDECIMAL:
            return SerializeBigDecimal.deSerialize(inputBuffer);
        case SERIALUID_BIGINTEGER:
            return SerializeBigInteger.deSerialize(inputBuffer);
        case SERIALUID_DATE:
            return SerializeDate.deSerialize(inputBuffer);
        case SERIALUID_INETADDRESS:
            return SerializeInetAddress.deSerialize(inputBuffer, 4);
        case SERIALUID_INETSOCKETADDRESS:
            return SerializeInetSocketAddress.deSerialize(inputBuffer, 4);
        case SERIALUID_STRING:
            return SerializeString.deSerialize(inputBuffer);
        case SERIALUID_TIME:
            return SerializeTime.deSerialize(inputBuffer);
        case SERIALUID_TIMESTAMP:
            return SerializeTimestamp.deSerialize(inputBuffer);
        case SERIALUID_VECTOR:
            return SerializeList.deSerializeVector(inputBuffer);
        case SERIALUID_ARRAYLIST:
            return SerializeList.deSerializeArrayList(inputBuffer);
        case SERIALUID_HASHTABLE:
            return SerializeMap.deSerializeHashtable(inputBuffer);
        case SERIALUID_HASHMAP:
            return SerializeMap.deSerializeHashMap(inputBuffer);
        case SERIALUID_BYTEARRAY:
            return SerializeByteArray.deSerialize(inputBuffer);
        case SERIALUID_BITID:
            return new BitID(inputBuffer);
        default:
            throw new RuntimeException(
                "SerializationManager: Unable to deserialize class:"
                + serialUID);
        }
    }
}