header.java

jsr-180 (SIP) 实现源码。可以在真实手机上使用

package com.micromethod.sipstack.ri;

import java.util.*;

import com.micromethod.sipstack.i.SipException;

/**
 * SipHeaderImpl
 */
public class Header {
  /**
   * ParametersContainer
   */
  private class ParametersContainer {
    /**
     * m_parameters
     */
    private Hashtable m_parameters = null;

    /**
     * m_listSeparator
     */
    private char m_listSeparator = 0;

    /**
     * m_authorizable
     */
    private boolean m_authorizable = false;

    /**
     * setAuthorization
     * 
     * @param enable
     * @param listSeparator
     */
    public void setAuthorization(boolean enable, char listSeparator) {
      m_authorizable = enable;
      m_listSeparator = listSeparator;
    }

    /**
     * contains
     * 
     * @param paramName
     * @return contains this Key
     */
    public boolean contains(String paramName) {
      if (paramName == null)
        return false;
      if (paramName.length() == 0)
        return false;
      else
        return m_parameters.containsKey(((Object) (paramName)));
    }

    /**
     * getParameter
     * 
     * @param paramName
     * @return value
     */
    public String getParameter(String paramName) {
      if (!contains(paramName)) {
        return null;
      }
      else {
        return (String) m_parameters.get(((Object) (paramName)));
      }
    }

    /**
     * getParameters
     * 
     * @return parameters
     */
    public Enumeration getParameters() {
      if (!hasParameter()) {
        return null;
      }
      else {
        return m_parameters.elements();
      }
    }

    /**
     * getParameterNames
     * 
     * @return parameterName String []
     */
    public String[] getParameterNames() {
      if (!hasParameter()) {
        return null;
      }
      Enumeration enumeration = m_parameters.keys();
      String as[] = new String[m_parameters.size()];
      for (short word0 = 0; enumeration.hasMoreElements(); word0++) {
        as[word0] = (String) enumeration.nextElement();
      }
      return as;
    }

    /**
     * hasParameter
     * 
     * @return hasParameter
     */
    public boolean hasParameter() {
      return m_parameters.size() != 0;
    }

    /**
     * removeParameter
     * 
     * @param paramName
     */
    public void removeParameter(String paramName) {
      if (paramName == null) {
        return;
      }
      if (paramName.length() == 0) {
        return;
      }
      if (!hasParameter()) {
        return;
      }
      else {
        m_parameters.remove(((Object) (paramName)));
        return;
      }
    }

    /**
     * clearParameters
     */
    public void clearParameters() {
      m_parameters.clear();
    }

    /**
     * setParameter
     * 
     * @param paramName
     * @param paramValue
     * @throws IllegalArgumentException
     * @throws SipException
     */
    public void setParameter(String paramName, String paramValue)
        throws IllegalArgumentException, SipException {
      if (paramName == null) {
        throw new NullPointerException("parameter name null");
      }
      if (paramName.length() == 0) {
        throw new IllegalArgumentException("parameter name empty");
      }
      if (paramValue == null) {
        throw new NullPointerException("parameter value null");
      }
      else {
        m_parameters.put(((Object) (paramName)), ((Object) (paramValue)));
        return;
      }
    }

    /**
     * toString
     * 
     * @return String
     */
    public String toString() {
      if (!hasParameter())
        return "";
      StringBuffer stringbuffer = new StringBuffer();
      Enumeration enumeration = m_parameters.keys();
      do {
        if (!enumeration.hasMoreElements())
          break;
        String s = (String) enumeration.nextElement();
        String s1 = (String) m_parameters.get(((Object) (s)));
        if (s1 != null) {
          if (!m_authorizable)
            stringbuffer.append(m_listSeparator);
          stringbuffer.append(s);
          if (s1.length() != 0) {
            stringbuffer.append('=');
            stringbuffer.append(s1);
          }
          if (m_authorizable && enumeration.hasMoreElements())
            stringbuffer.append(m_listSeparator);
        }
      }
      while (true);
      return stringbuffer.toString();
    }

    /**
     * Parameters Constructor
     * 
     */
    public ParametersContainer() {
      this(false, ';');
    }

    /**
     * Parameters Constructor
     * 
     * @param authorizable
     * @param listSeparator
     */
    public ParametersContainer(boolean authorizable, char listSeparator) {
      m_parameters = null;
      m_listSeparator = ';';
      m_authorizable = false;
      m_parameters = new Hashtable();
      m_listSeparator = listSeparator;
      m_authorizable = authorizable;
    }
  }

  /**
   * m_name
   */
  private String m_name = null;

  /**
   * m_value
   */
  private String m_value = null;

  /**
   * m_parametersContainer
   */
  private ParametersContainer m_parametersContainer = null;

  /**
   * m_authorization
   */
  private boolean m_authorization = false;

  private final short a = 0;

  private final short _fldfor = 1;

  private final short _fldcase = 2;

  private final short _fldbyte = 3;

  private short _fldif = 0;

  /**
   * m_listSeparatorChar
   */
  private short m_listSeparatorChar = 0;

  /**
   * SipHeaderImpl Constructor
   * 
   * @param name
   * @param value
   * @throws IllegalArgumentException
   */
  public Header(String name, String value) throws IllegalArgumentException {
    m_authorization = false;
    _fldif = -1;
    m_listSeparatorChar = 59;
    checkAuthorization(name);
    if (value == null)
      throw new NullPointerException(name + ": header value is null");
    if (m_authorization)
      m_parametersContainer = new ParametersContainer(true, ',');
    else
      m_parametersContainer = new ParametersContainer();
    try {
      parseParameters(value);
    }
    catch (SipException sipexception) {
      throw new IllegalArgumentException(sipexception.getMessage());
    }
  }

  /**
   * checkAuthorization
   * 
   * @param name
   * @throws IllegalArgumentException
   */
  private void checkAuthorization(String name) throws IllegalArgumentException {
    if (name == null)
      throw new NullPointerException("header name is null");
    name = name.trim();
    checkParameterName(name);
    m_name = name;
    if (m_name.equals("WWW-Authenticate")
        || m_name.equals("Proxy-Authenticate")
        || m_name.equals("Proxy-Authorization")
        || m_name.equals("Authorization")) {
      m_authorization = true;
      m_listSeparatorChar = 44;
      if (m_parametersContainer != null)
        m_parametersContainer
            .setAuthorization(true, (char) m_listSeparatorChar);
    }
    else {
      m_authorization = false;
      m_listSeparatorChar = 59;
      if (m_parametersContainer != null)
        m_parametersContainer.setAuthorization(false,
            (char) m_listSeparatorChar);
    }
  }

  /**
   * checkParameterName
   * 
   * @param name
   * @throws IllegalArgumentException
   */
  private void checkParameterName(String name) throws IllegalArgumentException {
    Vector vector = null;
    try {
      vector = SipHeaderParser.parseString(name);
    }
    catch (Exception exception) {
      throw new IllegalArgumentException("Illegal name '" + name + "'; "
          + exception.getMessage());
    }
    if (vector.size() != 2)
      throw new IllegalArgumentException("Illegal name '" + name + "'");
    Cache o1 = (Cache) vector.elementAt(0);
    if (o1.m_ctrlState != 1 && o1.m_ctrlState != 5)
      throw new IllegalArgumentException("Illegal name '" + name + "'");
    else
      return;
  }

  /**
   * checkParameterValue
   * 
   * @param value
   * @throws IllegalArgumentException
   */
  private void checkParameterValue(String value)
      throws IllegalArgumentException {
    Vector vector = null;
    try {
      vector = SipHeaderParser.parseString(value);
    }
    catch (Exception exception) {
      throw new IllegalArgumentException("Illegal parameter value '" + value
          + "'; " + exception.getMessage());
    }
    if (vector.size() == 1)
      return;
    Cache o1 = (Cache) vector.elementAt(0);
    if (o1.m_ctrlState != 1 && o1.m_ctrlState != 5 && o1.m_ctrlState != 3
        && o1.m_ctrlState != 7 && o1.m_ctrlState != 6)
      throw new IllegalArgumentException("3Illegal parameter value '" + value
          + "'");
    else
      return;
  }

  /**
   * setName
   * 
   * @param name