| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.axis2.util; |
| |
| import org.apache.axis2.context.externalize.ActivateUtils; |
| import org.apache.axis2.context.externalize.ExternalizeConstants; |
| import org.apache.axis2.context.externalize.SafeObjectInputStream; |
| import org.apache.axis2.context.externalize.SafeObjectOutputStream; |
| import org.apache.axis2.description.AxisMessage; |
| import org.apache.axis2.description.AxisOperation; |
| import org.apache.axis2.description.AxisService; |
| import org.apache.axis2.description.AxisServiceGroup; |
| import org.apache.axis2.engine.AxisConfiguration; |
| import org.apache.axis2.transport.TransportListener; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| import javax.xml.namespace.QName; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| import java.io.ObjectOutput; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.LinkedList; |
| import java.util.Map; |
| |
| /** |
| * Utility to write, read and activate externalized Objects |
| */ |
| public class ObjectStateUtils implements ExternalizeConstants { |
| /* |
| * setup for logging |
| */ |
| private static final Log log = LogFactory.getLog(ObjectStateUtils.class); |
| |
| // used to indicate an valid "null" object, |
| // typically used in key-value pairs where a non-null key refers to a null |
| // value |
| public static String NULL_OBJECT = "NULL_OBJ"; |
| |
| // message/trace/logging strings |
| public static final String UNSUPPORTED_SUID = "Serialization version ID is not supported."; |
| |
| public static final String UNSUPPORTED_REVID = "Revision ID is not supported."; |
| |
| // -------------------------------------------------------------------- |
| // Save/Restore methods |
| // -------------------------------------------------------------------- |
| |
| /** |
| * Write a string to the specified output stream. |
| * |
| * @param o The output stream |
| * @param str The string to write |
| * @param desc A text description to use for logging |
| * @throws IOException Exception |
| */ |
| public static void writeString(ObjectOutput o, String str, String desc) throws IOException { |
| SafeObjectOutputStream out = SafeObjectOutputStream.install(o); |
| out.writeUTF(desc); |
| out.writeObject(str); |
| } |
| |
| /** |
| * Read a string from the specified input stream. Returns null if no string is available. |
| * |
| * @param i The input stream |
| * @param desc A text description to use for logging |
| * @return The string or null, if not available |
| * @throws IOException |
| * @throws ClassNotFoundException |
| */ |
| public static String readString(ObjectInput i, String desc) throws IOException, |
| ClassNotFoundException { |
| SafeObjectInputStream in = SafeObjectInputStream.install(i); |
| |
| // Get the marker |
| in.readUTF(); |
| |
| // Get the object |
| return (String) in.readObject(); |
| } |
| |
| /** |
| * Write an object to the specified output stream. |
| * |
| * @param o The output stream |
| * @param obj The object to write |
| * @param desc A text description to use for logging |
| * @throws IOException Exception |
| */ |
| public static void writeObject(ObjectOutput o, Object obj, String desc) throws IOException { |
| SafeObjectOutputStream out = SafeObjectOutputStream.install(o); |
| out.writeUTF(desc); |
| out.writeObject(obj); |
| } |
| |
| /** |
| * Read an object from the specified input stream. Returns null if no object is available. |
| * |
| * @param i The input stream |
| * @param desc A text description to use for logging |
| * @return The object or null, if not available |
| * @throws IOException |
| * @throws ClassNotFoundException |
| */ |
| public static Object readObject(ObjectInput i, String desc) throws IOException, |
| ClassNotFoundException { |
| SafeObjectInputStream in = SafeObjectInputStream.install(i); |
| in.readUTF(); // Read Marker |
| return in.readObject(); |
| } |
| |
| /** |
| * Write an array of objects to the specified output stream. NOTE: each object in the array |
| * should implement either java.io.Serializable or java.io.Externalizable in order to be saved |
| * |
| * @param o The output stream |
| * @param al The ArrayList to write |
| * @param desc A text description to use for logging |
| * @throws IOException Exception |
| */ |
| public static void writeArrayList(ObjectOutput o, ArrayList al, String desc) |
| throws IOException { |
| SafeObjectOutputStream out = SafeObjectOutputStream.install(o); |
| out.writeUTF(desc); |
| out.writeList(al); |
| } |
| |
| /** |
| * Reads an array of objects from the specified input stream. Returns null if no array is |
| * available. NOTE: each object in the array should implement either java.io.Serializable or |
| * java.io.Externalizable in order to be saved |
| * |
| * @param i The input stream |
| * @param desc A text description to use for logging |
| * @return The ArrayList or null, if not available |
| * @throws IOException |
| * @throws ClassNotFoundException |
| */ |
| public static ArrayList readArrayList(ObjectInput i, String desc) throws IOException { |
| SafeObjectInputStream in = SafeObjectInputStream.install(i); |
| in.readUTF(); |
| return in.readArrayList(); |
| } |
| |
| /** |
| * Write a hashmap of objects to the specified output stream. NOTE: each object in the map |
| * should implement either java.io.Serializable or java.io.Externalizable in order to be saved |
| * |
| * @param o The output stream |
| * @param map The HashMap to write |
| * @param desc A text description to use for logging |
| * @throws IOException Exception |
| */ |
| public static void writeHashMap(ObjectOutput o, HashMap map, String desc) throws IOException { |
| SafeObjectOutputStream out = SafeObjectOutputStream.install(o); |
| out.writeUTF(desc); |
| out.writeMap(map); |
| } |
| |
| /** |
| * Read a hashmap of objects from the specified input stream. Returns null if no hashmap is |
| * available. |
| * |
| * @param in The input stream |
| * @param desc A text description to use for logging |
| * @return The HashMap or null, if not available |
| * @throws IOException |
| * @throws ClassNotFoundException |
| */ |
| public static HashMap readHashMap(ObjectInput i, String desc) throws IOException { |
| SafeObjectInputStream in = SafeObjectInputStream.install(i); |
| in.readUTF(); |
| return in.readHashMap(); |
| } |
| |
| /** |
| * Write a linked list of objects to the specified output stream. <NOTE: each object in the |
| * array should implement either java.io.Serializable or java.io.Externalizable in order to be |
| * saved |
| * |
| * @param o The output stream |
| * @param list The LinkedList to write |
| * @param desc A text description to use for logging |
| * @throws IOException Exception |
| */ |
| public static void writeLinkedList(ObjectOutput o, LinkedList objlist, String desc) |
| throws IOException { |
| SafeObjectOutputStream out = SafeObjectOutputStream.install(o); |
| out.writeUTF(desc); |
| out.writeList(objlist); |
| |
| } |
| |
| /** |
| * Reads a linked list of objects from the specified input stream. Returns null if no array is |
| * available. |
| * |
| * @param in The input stream |
| * @param desc A text description to use for logging |
| * @return The linked list or null, if not available |
| * @throws IOException |
| * @throws ClassNotFoundException |
| */ |
| public static LinkedList readLinkedList(ObjectInput i, String desc) throws IOException { |
| SafeObjectInputStream in = SafeObjectInputStream.install(i); |
| in.readUTF(); |
| return in.readLinkedList(); |
| } |
| |
| // -------------------------------------------------------------------- |
| // Finder methods |
| // -------------------------------------------------------------------- |
| |
| /** |
| * Find the AxisOperation object that matches the criteria |
| * |
| * @param axisConfig The AxisConfiguration object |
| * @param opClassName the class name string for the target object (could be a derived class) |
| * @param opQName the name associated with the operation |
| * @return the AxisOperation object that matches the given criteria |
| */ |
| public static AxisOperation findOperation(AxisConfiguration axisConfig, String opClassName, |
| QName opQName) { |
| return ActivateUtils.findOperation(axisConfig, opClassName, opQName); |
| } |
| |
| /** |
| * Find the AxisOperation object that matches the criteria |
| * |
| * @param service The AxisService object |
| * @param opClassName The class name string for the target object (could be a derived class) |
| * @param opQName the name associated with the operation |
| * @return the AxisOperation object that matches the given criteria |
| */ |
| public static AxisOperation findOperation(AxisService service, |
| String opClassName, |
| QName opQName) { |
| return ActivateUtils.findOperation(service, opClassName, opQName); |
| } |
| |
| /** |
| * Find the AxisService object that matches the criteria |
| * |
| * @param axisConfig The AxisConfiguration object |
| * @param serviceClassName the class name string for the target object (could be a derived |
| * class) |
| * @param serviceName the name associated with the service |
| * @return the AxisService object that matches the criteria |
| */ |
| public static AxisService findService(AxisConfiguration axisConfig, String serviceClassName, |
| String serviceName) { |
| return ActivateUtils.findService(axisConfig, serviceClassName, serviceName); |
| } |
| |
| /** |
| * Find the AxisServiceGroup object that matches the criteria <p/> <B>Note<B> the saved |
| * service group meta information may not match up with any of the serviceGroups that |
| * are in the current AxisConfiguration object. |
| * |
| * @param axisConfig The AxisConfiguration object |
| * @param serviceGrpClassName the class name string for the target object (could be a derived |
| * class) |
| * @param serviceGrpName the name associated with the service group |
| * @return the AxisServiceGroup object that matches the criteria |
| */ |
| public static AxisServiceGroup findServiceGroup(AxisConfiguration axisConfig, |
| String serviceGrpClassName, |
| String serviceGrpName) { |
| return ActivateUtils.findServiceGroup(axisConfig, serviceGrpClassName, serviceGrpName); |
| } |
| |
| /** |
| * Find the AxisMessage object that matches the criteria |
| * |
| * @param op The AxisOperation object |
| * @param msgName The name associated with the message |
| * @param msgElementName The name associated with the message element |
| * @return the AxisMessage object that matches the given criteria |
| */ |
| public static AxisMessage findMessage(AxisOperation op, |
| String msgName, |
| String msgElementName) { |
| return ActivateUtils.findMessage(op, msgName, msgElementName); |
| } |
| |
| /** |
| * Find the Handler object that matches the criteria |
| * |
| * @param existingHandlers The list of existing handlers and phases |
| * @param handlerClassName the class name string for the target object (could be a derived |
| * class) |
| * @return the Handler object that matches the criteria |
| */ |
| public static Object findHandler(ArrayList existingHandlers, |
| MetaDataEntry metaDataEntry) |
| { |
| return ActivateUtils.findHandler(existingHandlers, metaDataEntry); |
| } |
| |
| /** |
| * Find the TransportListener object that matches the criteria <p/> <B>Note<B> the saved meta |
| * information may not match up with any of the objects that are in the current |
| * AxisConfiguration object. |
| * |
| * @param axisConfig The AxisConfiguration object |
| * @param listenerClassName the class name string for the target object (could be a derived |
| * class) |
| * @return the TransportListener object that matches the criteria |
| */ |
| public static TransportListener findTransportListener(AxisConfiguration axisConfig, |
| String listenerClassName) { |
| return ActivateUtils.findTransportListener(axisConfig, listenerClassName); |
| } |
| |
| /** |
| * Compares the two collections to see if they are equivalent. |
| * |
| * @param a1 The first collection |
| * @param a2 The second collection |
| * @param strict Indicates whether strict checking is required. Strict checking means that the |
| * two collections must have the same elements in the same order. |
| * Non-strict checking means that the two collections must have the same elements, |
| * but the order is not significant. |
| * @return TRUE if the two collections are equivalent FALSE, otherwise |
| */ |
| public static boolean isEquivalent(ArrayList a1, ArrayList a2, boolean strict) { |
| return ActivateUtils.isEquivalent(a1, a2, strict); |
| } |
| |
| /** |
| * Compares the two collections to see if they are equivalent. |
| * |
| * @param m1 The first collection |
| * @param m2 The second collection |
| * @param strict Indicates whether strict checking is required. Strict checking means that the |
| * two collections must have the same mappings. Non-strict checking means that the two |
| * collections must have the same keys. In both cases, the order is not significant. |
| * @return TRUE if the two collections are equivalent FALSE, otherwise |
| */ |
| public static boolean isEquivalent(Map m1, Map m2, boolean strict) { |
| return ActivateUtils.isEquivalent(m1, m2, strict); |
| } |
| |
| /** |
| * Compares the two collections to see if they are equivalent. |
| * |
| * @param l1 |
| * The first collection |
| * @param l2 |
| * The second collection |
| * @return TRUE if the two collections are equivalent FALSE, otherwise |
| */ |
| public static boolean isEquivalent(LinkedList l1, LinkedList l2) { |
| return ActivateUtils.isEquivalent(l1, l2); |
| } |
| } |