/*
* 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);
}
}