| /* |
| * Conditions Of Use |
| * |
| * This software was developed by employees of the National Institute of |
| * Standards and Technology (NIST), an agency of the Federal Government. |
| * Pursuant to title 15 Untied States Code Section 105, works of NIST |
| * employees are not subject to copyright protection in the United States |
| * and are considered to be in the public domain. As a result, a formal |
| * license is not needed to use the software. |
| * |
| * This software is provided by NIST as a service and is expressly |
| * provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED |
| * OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT |
| * AND DATA ACCURACY. NIST does not warrant or make any representations |
| * regarding the use of the software or the results thereof, including but |
| * not limited to the correctness, accuracy, reliability or usefulness of |
| * the software. |
| * |
| * Permission to use this software is contingent upon your acceptance |
| * of the terms of this agreement |
| * |
| * . |
| * |
| */ |
| /******************************************************************************* |
| * Product of NIST/ITL Advanced Networking Technologies Division (ANTD). * |
| ******************************************************************************/ |
| package gov.nist.javax.sip.header; |
| |
| import gov.nist.core.GenericObject; |
| import gov.nist.core.Separators; |
| import gov.nist.javax.sip.header.ims.PrivacyHeader; |
| |
| import javax.sip.header.Header; |
| import java.lang.reflect.Constructor; |
| import java.util.*; |
| |
| /** |
| * |
| * This is the root class for all lists of SIP headers. It imbeds a |
| * SIPObjectList object and extends SIPHeader Lists of ContactSIPObjects etc. |
| * derive from this class. This supports homogeneous lists (all elements in the |
| * list are of the same class). We use this for building type homogeneous lists |
| * of SIPObjects that appear in SIPHeaders |
| * |
| * @version 1.2 $Revision: 1.15 $ $Date: 2005/10/09 18:47:53 |
| */ |
| public abstract class SIPHeaderList<HDR extends SIPHeader> extends SIPHeader implements java.util.List<HDR>, Header { |
| |
| private static boolean prettyEncode = false; |
| /** |
| * hlist field. |
| */ |
| protected List<HDR> hlist; |
| |
| private Class<HDR> myClass; |
| |
| public String getName() { |
| return this.headerName; |
| } |
| |
| |
| private SIPHeaderList() { |
| hlist = new LinkedList<HDR>(); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param objclass |
| * Class to set |
| * @param hname |
| * String to set |
| */ |
| protected SIPHeaderList(Class<HDR> objclass, String hname) { |
| this(); |
| this.headerName = hname; |
| this.myClass = objclass; |
| } |
| |
| /** |
| * Concatenate the list of stuff that we are keeping around and also the |
| * text corresponding to these structures (that we parsed). |
| * |
| * @param objectToAdd |
| */ |
| public boolean add(HDR objectToAdd) { |
| hlist.add((HDR)objectToAdd); |
| return true; |
| } |
| |
| /** |
| * Concatenate the list of stuff that we are keeping around and also the |
| * text corresponding to these structures (that we parsed). |
| * |
| * @param obj |
| * Genericobject to set |
| */ |
| public void addFirst(HDR obj) { |
| hlist.add(0,(HDR) obj); |
| } |
| |
| /** |
| * Add to this list. |
| * |
| * @param sipheader |
| * SIPHeader to add. |
| * @param top |
| * is true if we want to add to the top of the list. |
| */ |
| public void add(HDR sipheader, boolean top) { |
| if (top) |
| this.addFirst(sipheader); |
| else |
| this.add(sipheader); |
| } |
| |
| /** |
| * Concatenate two compatible lists. This appends or prepends the new list |
| * to the end of this list. |
| * |
| * @param other |
| * SIPHeaderList to set |
| * @param topFlag |
| * flag which indicates which end to concatenate |
| * the lists. |
| * @throws IllegalArgumentException |
| * if the two lists are not compatible |
| */ |
| public void concatenate(SIPHeaderList<HDR> other, boolean topFlag) |
| throws IllegalArgumentException { |
| if (!topFlag) { |
| this.addAll(other); |
| } else { |
| // add given items to the top end of the list. |
| this.addAll(0, other); |
| } |
| |
| } |
| |
| |
| |
| /** |
| * Encode a list of sip headers. Headers are returned in cannonical form. |
| * |
| * @return String encoded string representation of this list of headers. |
| * (Contains string append of each encoded header). |
| */ |
| public String encode() { |
| return encode(new StringBuffer()).toString(); |
| } |
| |
| public StringBuffer encode(StringBuffer buffer) { |
| if (hlist.isEmpty()) { |
| buffer.append(headerName).append(':').append(Separators.NEWLINE); |
| } |
| else { |
| // The following headers do not have comma separated forms for |
| // multiple headers. Thus, they must be encoded separately. |
| if (this.headerName.equals(SIPHeaderNames.WWW_AUTHENTICATE) |
| || this.headerName.equals(SIPHeaderNames.PROXY_AUTHENTICATE) |
| || this.headerName.equals(SIPHeaderNames.AUTHORIZATION) |
| || this.headerName.equals(SIPHeaderNames.PROXY_AUTHORIZATION) |
| || (prettyEncode && |
| (this.headerName.equals(SIPHeaderNames.VIA) || this.headerName.equals(SIPHeaderNames.ROUTE) || this.headerName.equals(SIPHeaderNames.RECORD_ROUTE))) // Less confusing to read |
| || this.getClass().equals( ExtensionHeaderList.class) ) { |
| ListIterator<HDR> li = hlist.listIterator(); |
| while (li.hasNext()) { |
| HDR sipheader = (HDR) li.next(); |
| sipheader.encode(buffer); |
| } |
| } else { |
| // These can be concatenated together in an comma separated |
| // list. |
| buffer.append(headerName).append(Separators.COLON).append(Separators.SP); |
| this.encodeBody(buffer); |
| buffer.append(Separators.NEWLINE); |
| } |
| } |
| return buffer; |
| } |
| |
| /** |
| * Return a list of encoded strings (one for each sipheader). |
| * |
| * @return LinkedList containing encoded strings in this header list. an |
| * empty list is returned if this header list contains no sip |
| * headers. |
| */ |
| |
| public List<String> getHeadersAsEncodedStrings() { |
| List<String> retval = new LinkedList<String>(); |
| |
| ListIterator<HDR> li = hlist.listIterator(); |
| while (li.hasNext()) { |
| Header sipheader = li.next(); |
| retval.add(sipheader.toString()); |
| |
| } |
| |
| return retval; |
| |
| } |
| |
| /** |
| * Get the first element of this list. |
| * |
| * @return SIPHeader first element of the list. |
| */ |
| public Header getFirst() { |
| if (hlist == null || hlist.isEmpty()) |
| return null; |
| else |
| return hlist.get(0); |
| } |
| |
| /** |
| * Get the last element of this list. |
| * |
| * @return SIPHeader last element of the list. |
| */ |
| public Header getLast() { |
| if (hlist == null || hlist.isEmpty()) |
| return null; |
| return hlist.get(hlist.size() - 1); |
| } |
| |
| /** |
| * Get the class for the headers of this list. |
| * |
| * @return Class of header supported by this list. |
| */ |
| public Class<HDR> getMyClass() { |
| return this.myClass; |
| } |
| |
| /** |
| * Empty check |
| * |
| * @return boolean true if list is empty |
| */ |
| public boolean isEmpty() { |
| return hlist.isEmpty(); |
| } |
| |
| /** |
| * Get an initialized iterator for my imbedded list |
| * |
| * @return the generated ListIterator |
| */ |
| public ListIterator<HDR> listIterator() { |
| |
| return hlist.listIterator(0); |
| } |
| |
| /** |
| * Get the imbedded linked list. |
| * |
| * @return the imedded linked list of SIP headers. |
| */ |
| public List<HDR> getHeaderList() { |
| return this.hlist; |
| } |
| |
| /** |
| * Get the list iterator for a given position. |
| * |
| * @param position |
| * position for the list iterator to return |
| * @return the generated list iterator |
| */ |
| public ListIterator<HDR> listIterator(int position) { |
| return hlist.listIterator(position); |
| } |
| |
| /** |
| * Remove the first element of this list. |
| */ |
| public void removeFirst() { |
| if (hlist.size() != 0) |
| hlist.remove(0); |
| |
| } |
| |
| /** |
| * Remove the last element of this list. |
| */ |
| public void removeLast() { |
| if (hlist.size() != 0) |
| hlist.remove(hlist.size() - 1); |
| } |
| |
| /** |
| * Remove a sip header from this list of sip headers. |
| * |
| * @param obj |
| * SIPHeader to remove |
| * @return boolean |
| */ |
| public boolean remove(HDR obj) { |
| if (hlist.size() == 0) |
| return false; |
| else |
| return hlist.remove(obj); |
| } |
| |
| /** |
| * Set the root class for all objects inserted into my list (for assertion |
| * check) |
| * |
| * @param cl |
| * class to set |
| */ |
| protected void setMyClass(Class<HDR> cl) { |
| this.myClass = cl; |
| } |
| |
| /** |
| * convert to a string representation (for printing). |
| * |
| * @param indentation |
| * int to set |
| * @return String string representation of object (for printing). |
| */ |
| public String debugDump(int indentation) { |
| stringRepresentation = ""; |
| String indent = new Indentation(indentation).getIndentation(); |
| |
| String className = this.getClass().getName(); |
| sprint(indent + className); |
| sprint(indent + "{"); |
| |
| for (Iterator<HDR> it = hlist.iterator(); it.hasNext();) { |
| HDR sipHeader = (HDR) it.next(); |
| sprint(indent + sipHeader.debugDump()); |
| } |
| sprint(indent + "}"); |
| return stringRepresentation; |
| } |
| |
| /** |
| * convert to a string representation |
| * |
| * @return String |
| */ |
| public String debugDump() { |
| return debugDump(0); |
| } |
| |
| /** |
| * Array conversion. |
| * |
| * @return SIPHeader [] |
| */ |
| public Object[] toArray() { |
| return hlist.toArray(); |
| |
| } |
| |
| /** |
| * index of an element. |
| * |
| * @return index of the given element (-1) if element does not exist. |
| */ |
| public int indexOf(GenericObject gobj) { |
| return hlist.indexOf(gobj); |
| } |
| |
| /** |
| * insert at a location. |
| * |
| * @param index |
| * location where to add the sipHeader. |
| * @param sipHeader |
| * SIPHeader structure to add. |
| */ |
| |
| public void add(int index, HDR sipHeader) |
| throws IndexOutOfBoundsException { |
| hlist.add(index, sipHeader); |
| } |
| |
| /** |
| * Equality comparison operator. |
| * |
| * @param other |
| * the other object to compare with. true is returned iff the |
| * classes match and list of headers herein is equal to the list |
| * of headers in the target (order of the headers is not |
| * important). |
| */ |
| @SuppressWarnings("unchecked") |
| public boolean equals(Object other) { |
| |
| if (other == this) |
| return true; |
| |
| if (other instanceof SIPHeaderList) { |
| SIPHeaderList<SIPHeader> that = (SIPHeaderList<SIPHeader>) other; |
| if (this.hlist == that.hlist) |
| return true; |
| else if (this.hlist == null) |
| return that.hlist == null || that.hlist.size() == 0; |
| return this.hlist.equals(that.hlist); |
| } |
| return false; |
| } |
| |
| /** |
| * Template match against a template. null field in template indicates wild |
| * card match. |
| */ |
| public boolean match(SIPHeaderList<?> template) { |
| if (template == null) |
| return true; |
| if (!this.getClass().equals(template.getClass())) |
| return false; |
| SIPHeaderList<SIPHeader> that = (SIPHeaderList<SIPHeader>) template; |
| if (this.hlist == that.hlist) |
| return true; |
| else if (this.hlist == null) |
| return false; |
| else { |
| |
| for (Iterator<SIPHeader> it = that.hlist.iterator(); it.hasNext();) { |
| SIPHeader sipHeader = (SIPHeader) it.next(); |
| |
| boolean found = false; |
| for (Iterator<HDR> it1 = this.hlist.iterator(); it1.hasNext() |
| && !found;) { |
| SIPHeader sipHeader1 = (SIPHeader) it1.next(); |
| found = sipHeader1.match(sipHeader); |
| } |
| if (!found) |
| return false; |
| } |
| return true; |
| } |
| } |
| |
| |
| /** |
| * make a clone of this header list. |
| * |
| * @return clone of this Header. |
| */ |
| public Object clone() { |
| try { |
| Class<?> clazz = this.getClass(); |
| |
| Constructor<?> cons = clazz.getConstructor((Class[])null); |
| SIPHeaderList<HDR> retval = (SIPHeaderList<HDR>) cons.newInstance((Object[])null); |
| retval.headerName = this.headerName; |
| retval.myClass = this.myClass; |
| return retval.clonehlist(this.hlist); |
| } catch (Exception ex) { |
| throw new RuntimeException("Could not clone!", ex); |
| } |
| } |
| |
| protected final SIPHeaderList<HDR> clonehlist(List<HDR> hlistToClone) { |
| if (hlistToClone != null) { |
| for (Iterator<HDR> it = (Iterator<HDR>) hlistToClone.iterator(); it.hasNext();) { |
| Header h = it.next(); |
| this.hlist.add((HDR)h.clone()); |
| } |
| } |
| return this; |
| } |
| |
| /** |
| * Get the number of headers in the list. |
| */ |
| public int size() { |
| return hlist.size(); |
| } |
| |
| /** |
| * Return true if this is a header list (overrides the base class method |
| * which returns false). |
| * |
| * @return true |
| */ |
| public boolean isHeaderList() { |
| return true; |
| } |
| |
| /** |
| * Encode the body of this header (the stuff that follows headerName). A.K.A |
| * headerValue. This will not give a reasonable result for WWW-Authenticate, |
| * Authorization, Proxy-Authenticate and Proxy-Authorization and hence this |
| * is protected. |
| */ |
| protected String encodeBody() { |
| return encodeBody(new StringBuffer()).toString(); |
| } |
| |
| protected StringBuffer encodeBody(StringBuffer buffer) { |
| ListIterator<HDR> iterator = this.listIterator(); |
| while (true) { |
| SIPHeader sipHeader = (SIPHeader) iterator.next(); |
| if ( sipHeader == this ) throw new RuntimeException ("Unexpected circularity in SipHeaderList"); |
| sipHeader.encodeBody(buffer); |
| // if (body.equals("")) System.out.println("BODY == "); |
| if (iterator.hasNext()) { |
| if (!this.headerName.equals(PrivacyHeader.NAME)) |
| buffer.append(Separators.COMMA); |
| else |
| buffer.append(Separators.SEMICOLON); |
| continue; |
| } else |
| break; |
| |
| } |
| return buffer; |
| } |
| |
| public boolean addAll(Collection<? extends HDR> collection) { |
| return this.hlist.addAll(collection); |
| } |
| |
| public boolean addAll(int index, Collection<? extends HDR> collection) { |
| return this.hlist.addAll(index, collection); |
| |
| } |
| |
| public boolean containsAll(Collection<?> collection) { |
| return this.hlist.containsAll(collection); |
| } |
| |
| |
| |
| |
| public void clear() { |
| this.hlist.clear(); |
| } |
| |
| public boolean contains(Object header) { |
| return this.hlist.contains(header); |
| } |
| |
| |
| /** |
| * Get the object at the specified location. |
| * |
| * @param index -- |
| * location from which to get the object. |
| * |
| */ |
| public HDR get(int index) { |
| return this.hlist.get(index); |
| } |
| |
| /** |
| * Return the index of a given object. |
| * |
| * @param obj -- |
| * object whose index to compute. |
| */ |
| public int indexOf(Object obj) { |
| return this.hlist.indexOf(obj); |
| } |
| |
| /** |
| * Return the iterator to the imbedded list. |
| * |
| * @return iterator to the imbedded list. |
| * |
| */ |
| |
| public java.util.Iterator<HDR> iterator() { |
| return this.hlist.listIterator(); |
| } |
| |
| /** |
| * Get the last index of the given object. |
| * |
| * @param obj -- |
| * object whose index to find. |
| */ |
| public int lastIndexOf(Object obj) { |
| |
| return this.hlist.lastIndexOf(obj); |
| } |
| |
| /** |
| * Remove the given object. |
| * |
| * @param obj -- |
| * object to remove. |
| * |
| */ |
| |
| public boolean remove(Object obj) { |
| |
| return this.hlist.remove(obj); |
| } |
| |
| /** |
| * Remove the object at a given index. |
| * |
| * @param index -- |
| * index at which to remove the object |
| */ |
| |
| public HDR remove(int index) { |
| return this.hlist.remove(index); |
| } |
| |
| /** |
| * Remove all the elements. |
| * @see List#removeAll(java.util.Collection) |
| */ |
| public boolean removeAll(java.util.Collection<?> collection) { |
| return this.hlist.removeAll(collection); |
| } |
| |
| |
| /** |
| * @see List#retainAll(java.util.Collection) |
| * @param collection |
| */ |
| public boolean retainAll(java.util.Collection<?> collection) { |
| return this.hlist.retainAll(collection); |
| } |
| |
| /** |
| * Get a sublist of the list. |
| * |
| * @see List#subList(int, int) |
| */ |
| public java.util.List<HDR> subList(int index1, int index2) { |
| return this.hlist.subList(index1, index2); |
| |
| } |
| |
| /** |
| * @see Object#hashCode() |
| * @return -- the computed hashcode. |
| */ |
| public int hashCode() { |
| |
| return this.headerName.hashCode(); |
| } |
| |
| /** |
| * Set a SIPHeader at a particular position in the list. |
| * |
| * @see List#set(int, java.lang.Object) |
| */ |
| public HDR set(int position, HDR sipHeader) { |
| |
| return hlist.set(position, sipHeader); |
| |
| } |
| |
| |
| public static void setPrettyEncode(boolean flag) { |
| prettyEncode = flag; |
| } |
| |
| |
| public <T> T[] toArray(T[] array) { |
| return this.hlist.toArray(array); |
| } |
| |
| |
| } |
