public ParameterIncludeImpl() 
{
           
        parameters = new HashMap< String, Parameter >();
}

Constructor ParameterIncludeImpl.

 public  void addParameter(Parameter param) 
{
        if (param != null) {
            parameters.put(param.getName(), param);
            if (DEBUG_ENABLED) {
                this.debugParameterAdd(param);
            }
        }
}

Method addParameter

 public  void deserializeParameters(OMElement parameters) throws AxisFault 
{
        Iterator iterator =
                parameters.getChildrenWithName(new QName(DeploymentConstants.TAG_PARAMETER));
        while (iterator.hasNext()) {
            // this is to check whether some one has locked the parmeter at the top level
            OMElement parameterElement = (OMElement) iterator.next();
            Parameter parameter = new Parameter();
            // setting parameterElement
            parameter.setParameterElement(parameterElement);
            // setting parameter Name
            OMAttribute paraName =
                    parameterElement.getAttribute(new QName(DeploymentConstants.ATTRIBUTE_NAME));
            parameter.setName(paraName.getAttributeValue());
            // setting parameter Value (the child element of the parameter)
            OMElement paraValue = parameterElement.getFirstElement();
            if (paraValue != null) {
                parameter.setValue(parameterElement);
                parameter.setParameterType(Parameter.OM_PARAMETER);
            } else {
                String paratextValue = parameterElement.getText();
                parameter.setValue(paratextValue);
                parameter.setParameterType(Parameter.TEXT_PARAMETER);
            }
            // setting locking attribute
            OMAttribute paraLocked =
                    parameterElement.getAttribute(new QName(DeploymentConstants.ATTRIBUTE_LOCKED));
            if (paraLocked != null) {
                String lockedValue = paraLocked.getAttributeValue();
                if ("true".equals(lockedValue)) {
                    parameter.setLocked(true);
                } else {
                    parameter.setLocked(false);
                }
            }
            addParameter(parameter);
        }
}

Since at runtime it parameters may be modified to get the original state this method can be used

 public Parameter getParameter(String name) 
{
        return (Parameter) parameters.get(name);
}

Method getParameter.

 public ArrayList getParameters() 
{
        Collection< Parameter > col = parameters.values();
        ArrayList< Parameter > para_list = new ArrayList< Parameter >();
        for (Iterator< Parameter > iterator = col.iterator(); iterator.hasNext();) {
            Parameter parameter = (Parameter) iterator.next();
            para_list.add(parameter);
        }
        return para_list;
}

 public boolean isParameterLocked(String parameterName) 
{
        return false;
}

 public  void readExternal(ObjectInput inObject) throws ClassNotFoundException, IOException 
{
        SafeObjectInputStream in = SafeObjectInputStream.install(inObject);
        // trace point
        if (log.isTraceEnabled()) {
            log.trace(myClassName + ":readExternal():  BEGIN  bytes available in stream [" +
                    in.available() + "]  ");
        }
        // serialization version ID
        long suid = in.readLong();
        // revision ID
        int revID = in.readInt();
        // make sure the object data is in a version we can handle
        if (suid != serialVersionUID) {
            throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_SUID);
        }
        // make sure the object data is in a revision level we can handle
        if (revID != REVISION_2) {
            throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_REVID);
        }
        //---------------------------------------------------------
        // collection of parameters
        //---------------------------------------------------------
        in.readMap(parameters);
        //---------------------------------------------------------
        // done
        //---------------------------------------------------------
}

Restore the contents of the object that was previously saved.

NOTE: The field data must read back in the same order and type as it was written. Some data will need to be validated when resurrected.

 public  void removeParameter(Parameter param) throws AxisFault 
{
        parameters.remove(param.getName());
}

 public  void writeExternal(ObjectOutput o) throws IOException 
{
        SafeObjectOutputStream out = SafeObjectOutputStream.install(o);
        // write out contents of this object
        //---------------------------------------------------------
        // in order to handle future changes to the message 
        // context definition, be sure to maintain the 
        // object level identifiers
        //---------------------------------------------------------
        // serialization version ID
        out.writeLong(serialVersionUID);
        // revision ID
        out.writeInt(revisionID);
        //---------------------------------------------------------
        // collection of parameters
        //---------------------------------------------------------
        out.writeMap(parameters);
}

Save the contents of this object.

NOTE: Transient fields and static fields are not saved. Also, objects that represent "static" data are not saved, except for enough information to be able to find matching objects when the message context is re-constituted.