View Javadoc

1   package org.codehaus.xfire.service;
2   
3   import java.util.Collections;
4   import java.util.HashMap;
5   import java.util.LinkedList;
6   import java.util.List;
7   import java.util.Map;
8   
9   import javax.xml.namespace.QName;
10  
11  /***
12   * Represents the base class for containers of <code>MessagePartInfo</code> objects.
13   *
14   * @author <a href="mailto:poutsma@mac.com">Arjen Poutsma</a>
15   */
16  public abstract class MessagePartContainer
17  {
18      /***
19       * The operation that this <code>MessageInfo</code> is a part of.
20       */
21      private OperationInfo operation;
22      private Map messageHeaders = new HashMap();
23      private Map messageParts = new HashMap();
24      private List messageHeaderList = new LinkedList();
25      private List messagePartList = new LinkedList();
26  
27      /***
28       * Initializes a new instance of the <code>MessagePartContainer</code>.
29       *
30       * @param operation the operation.
31       */
32      protected MessagePartContainer(OperationInfo operation)
33      {
34          this.operation = operation;
35      }
36  
37      /***
38       * Returns the operation of this container.
39       *
40       * @return the operation.
41       */
42      public OperationInfo getOperation()
43      {
44          return operation;
45      }
46  
47      /***
48       * Adds an message part to this conainer.
49       *
50       * @param name  the qualified name of the message part.
51       * @param clazz the type of the message part.
52       */
53      public MessagePartInfo addMessagePart(QName name, Class clazz)
54      {
55          if (name == null)
56          {
57              throw new IllegalArgumentException("Invalid name [" + name + "]");
58          }
59          if (messageParts.containsKey(name))
60          {
61              throw new IllegalArgumentException(
62                      "An message part with name [" + name + "] already exists in this container");
63          }
64  
65          MessagePartInfo part = new MessagePartInfo(name, clazz, this);
66          addMessagePart(part);
67          return part;
68      }
69  
70      /***
71       * Adds an message part to this conainer.
72       *
73       * @param name  the qualified name of the message part.
74       * @param clazz the type of the message part.
75       */
76      public MessageHeaderInfo addMessageHeader(QName name, Class clazz)
77      {
78          if (name == null)
79          {
80              throw new IllegalArgumentException("Invalid name [" + name + "]");
81          }
82          if (messageParts.containsKey(name))
83          {
84              throw new IllegalArgumentException(
85                      "An message header with name [" + name + "] already exists in this container");
86          }
87  
88          MessageHeaderInfo part = new MessageHeaderInfo(name, clazz, this);
89          addMessageHeader(part);
90          return part;
91      }
92      
93      /***
94       * Adds an message part to this container.
95       *
96       * @param part the message part.
97       */
98      public void addMessagePart(MessagePartInfo part)
99      {
100         messageParts.put(part.getName(), part);
101         messagePartList.add(part);
102     }
103     
104     /***
105      * Adds an message header to this container.
106      *
107      * @param header the message part.
108      */
109     public void addMessageHeader(MessageHeaderInfo header)
110     {
111         messageHeaders.put(header.getName(), header);
112         messageHeaderList.add(header);
113     }
114     
115     public int getMessagePartIndex(MessagePartInfo part)
116     {
117         return messagePartList.indexOf(part);
118     }
119 
120     /***
121      * Removes an message part from this container.
122      *
123      * @param name the qualified message part name.
124      */
125     public void removeMessagePart(QName name)
126     {
127         MessagePartInfo messagePart = getMessagePart(name);
128         if (messagePart != null)
129         {
130             messageParts.remove(name);
131             messagePartList.remove(messagePart);
132         }
133     }
134 
135     /***
136      * Removes an message header from this container.
137      *
138      * @param name the qualified message header name.
139      */
140     public void removeMessageHeader(QName name)
141     {
142         MessageHeaderInfo messageHeader = getMessageHeader(name);
143         if (messageHeader != null)
144         {
145             messageHeaders.remove(name);
146             messageHeaderList.remove(messageHeader);
147         }
148     }
149     
150     /***
151      * Returns the message part with the given name, if found.
152      *
153      * @param name the qualified name.
154      * @return the message part; or <code>null</code> if not found.
155      */
156     public MessagePartInfo getMessagePart(QName name)
157     {
158         return (MessagePartInfo) messageParts.get(name);
159     }
160     
161     /***
162      * Returns the message part with the given name, if found.
163      *
164      * @param name the qualified name.
165      * @return the message part; or <code>null</code> if not found.
166      */
167     public MessageHeaderInfo getMessageHeader(QName name)
168     {
169         return (MessageHeaderInfo) messageHeaders.get(name);
170     }
171     
172     /***
173      * Returns all message parts for this message.
174      *
175      * @return all message parts.
176      */
177     public List getMessageParts()
178     {
179         return Collections.unmodifiableList(messagePartList);
180     }
181     
182     /***
183      * Returns all message headers for this message.
184      *
185      * @return all message parts.
186      */
187     public List getMessageHeaders()
188     {
189         return Collections.unmodifiableList(messageHeaderList);
190     }
191 }