UDDIProxy


1   /*
2    * The source code contained herein is licensed under the IBM Public License
3    * Version 1.0, which has been approved by the Open Source Initiative.
4    * Copyright (C) 2001, International Business Machines Corporation
5    * Copyright (C) 2001, Hewlett-Packard Company
6    * All Rights Reserved.
7    *
8    */
9   package org.uddi4j.client;
10  
11  
12  import java.net.MalformedURLException  ;
13  import java.net.URL  ;
14  import java.util.Arrays  ;
15  import java.util.Properties  ;
16  import java.util.Vector  ;
17  
18  import org.uddi4j.UDDIElement;
19  import org.uddi4j.UDDIException;
20  import org.uddi4j.datatype.Name;
21  import org.uddi4j.datatype.assertion.PublisherAssertion;
22  import org.uddi4j.request.AddPublisherAssertions;
23  import org.uddi4j.request.DeleteBinding;
24  import org.uddi4j.request.DeleteBusiness;
25  import org.uddi4j.request.DeletePublisherAssertions;
26  import org.uddi4j.request.DeleteService;
27  import org.uddi4j.request.DeleteTModel;
28  import org.uddi4j.request.DiscardAuthToken;
29  import org.uddi4j.request.FindBinding;
30  import org.uddi4j.request.FindBusiness;
31  import org.uddi4j.request.FindRelatedBusinesses;
32  import org.uddi4j.request.FindService;
33  import org.uddi4j.request.FindTModel;
34  import org.uddi4j.request.GetAssertionStatusReport;
35  import org.uddi4j.request.GetAuthToken;
36  import org.uddi4j.request.GetBindingDetail;
37  import org.uddi4j.request.GetBusinessDetail;
38  import org.uddi4j.request.GetBusinessDetailExt;
39  import org.uddi4j.request.GetPublisherAssertions;
40  import org.uddi4j.request.GetRegisteredInfo;
41  import org.uddi4j.request.GetServiceDetail;
42  import org.uddi4j.request.GetTModelDetail;
43  import org.uddi4j.request.SaveBinding;
44  import org.uddi4j.request.SaveBusiness;
45  import org.uddi4j.request.SaveService;
46  import org.uddi4j.request.SaveTModel;
47  import org.uddi4j.request.SetPublisherAssertions;
48  import org.uddi4j.request.ValidateValues;
49  import org.uddi4j.response.AssertionStatusReport;
50  import org.uddi4j.response.AuthToken;
51  import org.uddi4j.response.BindingDetail;
52  import org.uddi4j.response.BusinessDetail;
53  import org.uddi4j.response.BusinessDetailExt;
54  import org.uddi4j.response.BusinessList;
55  import org.uddi4j.response.CompletionStatus;
56  import org.uddi4j.response.DispositionReport;
57  import org.uddi4j.response.PublisherAssertions;
58  import org.uddi4j.response.RegisteredInfo;
59  import org.uddi4j.response.RelatedBusinessesList;
60  import org.uddi4j.response.ServiceDetail;
61  import org.uddi4j.response.ServiceList;
62  import org.uddi4j.response.TModelDetail;
63  import org.uddi4j.response.TModelList;
64  import org.uddi4j.transport.TransportException;
65  import org.uddi4j.transport.TransportFactory;
66  import org.uddi4j.util.AuthInfo;
67  import org.uddi4j.util.CategoryBag;
68  import org.uddi4j.util.DiscoveryURLs;
69  import org.uddi4j.util.FindQualifiers;
70  import org.uddi4j.util.IdentifierBag;
71  import org.uddi4j.util.KeyedReference;
72  import org.uddi4j.util.TModelBag;
73  import org.uddi4j.util.UploadRegister;
74  import org.w3c.dom.Element  ;
75  
76  /**
77   * Represents a UDDI server and the actions that can be
78   * invoked against it.<P>
79   *
80   * The API is described in the UDDI API specification
81   * available from <A HREF="http://www.uddi.org">
82   * http://www.uddi.org </A>.
83   *
84   * The UDDI API specification is required to understand
85   * and utilize this API. This class attempts to closely
86   * pattern the API document.<P>
87   *
88   * @author David Melgar (dmelgar@us.ibm.com)
89   * @author Ravi Trivedi (ravi_trivedi@hp.com)
90   * @author Vivek Chopra (vivek@soaprpc.com)
91   * @author Ozzy (ozzy@hursley.ibm.com)
92   */
93  public class UDDIProxy {
94  
95     // Variables
96     protected URL   inquiryURL = null;
97     protected URL   publishURL = null;
98     TransportFactory transportFactory = null;
99     Properties      config     = null;
100 
101 
102    /**
103     * Default constructor.
104    */
105    public UDDIProxy() {
106       transportFactory = TransportFactory.newInstance();
107    }
108 
109    /**
110     * Construct a UDDIProxy object.
111     *
112     * @param inquiryURL URL to be used for inquiry requests.
113     * @param publishURL URL to be used for publish requests.
114     */
115    public UDDIProxy(URL   inquiryURL, URL   publishURL) {
116       this();
117       this.inquiryURL = inquiryURL;
118       this.publishURL = publishURL;
119    }
120 
121    /**
122     * Construct a UDDIProxy object
123     * 
124     * @param p      Properties object which contains configuration information for
125     *               UDDI4J. This properties object overrides settings normally retrieved
126     *               from system properties. 
127     *               <P>
128     *               This object may also specify properties affecting UDDIProxy.
129     *               Current settings affected by this properties object include:
130     *               <DL>
131     *               <DT>org.uddi4j.TransportClassName
132     *               <DD>Specifies the name of the SOAP transport support class.
133     *               Options include, org.uddi4j.transport.ApacheSOAPTransport,
134     *               org.uddi4j.transport.ApacheAxisTransport,
135     *               org.uddi4j.transport.HPSOAPTransport.
136     *               <DT>org.uddi4j.inquiryURL
137     *               <DD>The URL to be used by UDDIProxy for inquiry requests.
138     *               setInquiryURL method overrides.
139     *               <DT>org.uddi4j.publishURL
140     *               <DD>The URL to be used by UDDIProxy for publish requests.
141     *               setPublishURL methods override.
142     *               </DL>
143     * @exception java.net.MalformedURLException In case the publish or
144     *            inquiry URLs are malformed.
145     */
146    public UDDIProxy(Properties   p) throws MalformedURLException   {
147       setConfiguration(p);
148    }
149 
150    /**
151     * Set the configuration properties
152     * 
153     * @param p Properties object containing configuration information. See
154     * {@link #UDDIProxy(Properties)} for configuration details.
155     * @exception java.net.MalformedURLException In case the publish or
156     *            inquiry URLs are malformed.
157     */
158    public void setConfiguration(Properties   p) throws MalformedURLException   {
159       // Save the property object within the proxy
160       config = p;
161 
162       // use it in send to create factory, or create in the proxy
163       transportFactory = TransportFactory.newInstance(p);
164       if (p.getProperty("org.uddi4j.inquiryURL") != null) {
165          setInquiryURL(p.getProperty( "org.uddi4j.inquiryURL"));
166       }
167       if (p.getProperty("org.uddi4j.publishURL") != null) {
168          setPublishURL(p.getProperty("org.uddi4j.publishURL"));
169       }
170    }
171 
172    /**
173     * Get the configuration properties
174     * @return The configuration properties
175     */
176    public Properties   getConfiguration() {
177       return config;
178    }
179 
180    /**
181     * Set the URL to be used for inquiry requests.
182     *
183     * @param url Inquiry URL string
184     * @exception java.net.MalformedURLException In case the Inquiry URL is
185     * malformed.
186     */
187    public void setInquiryURL(String   url) throws java.net.MalformedURLException   {
188       this.inquiryURL = new java.net.URL  (url);
189    }
190 
191    /**
192     * Set the URL to be used for inquiry requests.
193     *
194     * @param url Inquiry URL
195     */
196    public void setInquiryURL(URL   url) {
197       this.inquiryURL = url;
198    }
199 
200    /**
201     * Set the URL to be used for publish requests. If
202     * HTTPS is specified as the procotol, it must be added
203     * as a supported protocol. For Sun's SSL support, this can be done
204     * with the following code fragment:
205     * <PRE>
206     *    System.setProperty("java.protocol.handler.pkgs",
207     *                       "com.sun.net.ssl.internal.www.protocol");
208     *    java.security.Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
209     * </PRE>
210     *
211     * @param url
212     * @exception java.net.MalformedURLException
213     *                   Thrown if HTTPS is not registered as a valid URL protocol.
214     */
215    public void setPublishURL(String   url) throws java.net.MalformedURLException   {
216       this.publishURL = new java.net.URL  (url);
217    }
218 
219    /**
220     * Set the URL to be used for publish requests.
221     *
222     * @param url Publish URL
223     */
224    public void setPublishURL(URL   url) {
225       this.publishURL = url;
226    }
227 
228 
229    /**
230     * The find_binding method returns a bindingDetail message that contains
231     * a bindingTemplates structure with zero or more bindingTemplate structures
232     * matching the criteria specified in the argument list.
233     *
234     * @param findQualifiers
235     *                   This collection of findQualifier elements can be used to alter the default
236     *                   behavior of search functionality.
237     * @param serviceKey Used to specify a particular instance of a businessService element
238     *                   in the registered data.  Only bindings in the specific businessService
239     *                   data identified by the serviceKey passed will be searched.
240     * @param tModelBag  This is a list of tModel uuid_key values that represent the technical
241     *                   fingerprint to locate in a bindingTemplate structure contained within
242     *                   the businessService instance specified by the serviceKey value.  If more
243     *                   than one tModel key is specified in this structure, only bindingTemplate
244     *                   information that exactly matches all of the tModel keys specified will
245     *                   be returned (logical AND).  The order of the keys in the tModelBag is
246     *                   not relevant.  All tModelKey values begin with a uuid URN qualifier
247     *                   (e.g. "uuid:" followed by a known tModel UUID value.
248     * @param maxRows    This optional integer value allows the requesting program to limit
249     *                   the number of results returned.
250     * @return This function returns a bindingDetail message on success.  In the event that no matches were
251     * located for the specified criteria, the bindingDetail structure returned in the response the will be
252     * empty (e.g. contain no bindingTemplate data.)
253     *         In the even of a large number of matches, an Operator Site may truncate the result set.  If
254     * this occurs, the response message will contain the truncated attribute with the value of this attribute
255     * set to true.
256     *         Searching using tModelBag will also return any bindingTemplate information that matches due to
257     * hostingRedirector references.  The resolved bindingTemplate structure will be returned, even if that
258     * bindingTemplate is owned by a different businessService structure.
259     * @exception UDDIException
260     * @exception TransportException
261     */
262    public BindingDetail find_binding(FindQualifiers findQualifiers,
263                                      String   serviceKey,
264                                      TModelBag tModelBag,
265                                      int maxRows)
266           throws UDDIException, TransportException {
267       FindBinding request = new FindBinding();
268       request.setFindQualifiers(findQualifiers);
269       request.setServiceKey(serviceKey);
270       request.setTModelBag(tModelBag);
271       if (maxRows>0) request.setMaxRows(maxRows);
272       return new BindingDetail(send(request, true));
273    }
274 
275    /**
276     * Find business matching specified criteria.
277     *
278     * @param name    Partial business name to match. Leftmost match.
279     * @param findQualifiers
280     *                Optional findQualifiers. null indicates no find
281     *                qualifiers.
282     * @param maxRows Maximum number of results. 0 indicates no maximum.
283     * @return This function returns a businessList on success.  In the event that no
284     *         matches were located for the specified criteria, a businessList
285     *         structure with zero businessInfo structures is returned.
286     * @exception UDDIException
287     *                   Contains a DispositionReport that indicates the
288     *                   error number.
289     * @exception TransportException
290     *                   Thrown if non-UDDI related communication errors occur.
291     * @deprecated This method has been deprecated. Use
292     * {@link #find_business(Vector, DiscoveryURLs, IdentifierBag, CategoryBag, TModelBag,
293     *                       FindQualifiers, int)} instead
294     *
295     */
296    public BusinessList find_business(String   name,
297                                      FindQualifiers findQualifiers,
298                                      int maxRows)
299           throws UDDIException, TransportException {
300       Vector   names = new Vector  ();
301       names.addElement(new Name(name));
302       return find_business(names, null, null, null, null,  findQualifiers, maxRows);
303    }
304    /**
305     * The find_business message returns a businessList message that matches
306     * the conditions specified in the arguments.
307     *
308     * @param identifierBag
309     *                This is a list of business identifier references. The returned businessList
310     *                contains businessInfo structures matching any of the identifiers passed
311     *                (logical OR).
312     * @param findQualifiers
313     *                can be used to alter the default behavior of search functionality.
314     * @param maxRows allows the requesting program to limit the number of results returned.
315     * @return This function returns a businessList on success.  In the event that no
316     *         matches were located for the specified criteria, a businessList
317     *         structure with zero businessInfo structures is returned.
318     * @exception UDDIException
319     * @exception TransportException
320     * @deprecated This method has been deprecated. Use
321     * {@link #find_business(Vector, DiscoveryURLs, IdentifierBag, CategoryBag, TModelBag,
322     *                       FindQualifiers, int)} instead
323     */
324    public BusinessList find_business(IdentifierBag identifierBag,
325                                      FindQualifiers findQualifiers,
326                                      int maxRows)
327           throws UDDIException, TransportException {
328      return find_business(new Vector  () , null, identifierBag, null, null, findQualifiers, maxRows);
329    }
330 
331    /**
332     * The find_business message returns a businessList message that matches
333     * the conditions specified in the arguments.
334     *
335     * @param categoryBag
336     *                This is a list of category references.  The returned businessList
337     *                contains businessInfo structures matching all of the categories
338     *                passed (logical AND).
339     * @param findQualifiers
340     *                can be used to alter the default behavior of search functionality.
341     * @param maxRows allows the requesting program to limit the number of results returned.
342     * @return This function returns a businessList on success.  In the event that no
343     *         matches were located for the specified criteria, a businessList
344     *         structure with zero businessInfo structures is returned.
345     * @exception UDDIException
346     * @exception TransportException
347     * @deprecated This method has been deprecated. Use
348     * {@link #find_business(Vector, DiscoveryURLs, IdentifierBag, CategoryBag, TModelBag,
349     *                       FindQualifiers, int)} instead
350     */
351    public BusinessList find_business(CategoryBag categoryBag,
352                                      FindQualifiers findQualifiers,
353                                      int maxRows)
354           throws UDDIException, TransportException {
355       return find_business(new Vector  (), null , null , categoryBag, null , findQualifiers, maxRows);
356    }
357 
358    /**
359     * The find_business message returns a businessList message that matches
360     * the conditions specified in the arguments.
361     *
362     * @param tModelBag
363     *                The registered businessEntity data contains bindingTemplates that in turn
364     *                contain specific tModel references.  The tModelBag argument lets you
365     *                search for businesses that have bindings that are compatible with a
366     *                specific tModel pattern.  The returned businessList contains businessInfo
367     *                structures that match all of the tModel keys passed (logical AND).
368     *                tModelKey values must be formatted as URN qualified UUID values
369     *                (e.g. prefixed with "uuid:")
370     * @param findQualifiers
371     *                can be used to alter the default behavior of search functionality.
372     * @param maxRows allows the requesting program to limit the number of results returned.
373     * @return This function returns a businessList on success.  In the event that no
374     *         matches were located for the specified criteria, a businessList
375     *         structure with zero businessInfo structures is returned.
376     * @exception UDDIException
377     * @exception TransportException
378     * @deprecated This method has been deprecated.Use
379     * {@link #find_business(Vector, DiscoveryURLs, IdentifierBag, CategoryBag, TModelBag,
380     *                       FindQualifiers, int)} instead
381     */
382    public BusinessList find_business(TModelBag tModelBag,
383                                      FindQualifiers findQualifiers,
384                                      int maxRows)
385           throws UDDIException, TransportException {
386      return find_business(new Vector  (), null , null,  null, tModelBag,  findQualifiers, maxRows);
387    }
388 
389    /**
390     * The find_business message returns a businessList message that matches
391     * the conditions specified in the arguments.
392     *
393     * @param discoveryURLs
394     *                This is a list of URL's to be matched against the data associated
395     *                with the discoveryURL's contents of registered businessEntity information.
396     *                To search for URL without regard to useType attribute values, pass
397     *                the useType component of the discoveryURL elements as empty attributes.
398     *                If useType values are included, then the match will be made only on
399     *                registered information that match both the useType and URL value.
400     *                The returned businessList contains businessInfo structures matching
401     *                any of the URL's passed (logical OR).
402     * @param findQualifiers
403     *                can be used to alter the default behavior of search functionality.
404     * @param maxRows allows the requesting program to limit the number of results returned.
405     * @return This function returns a businessList on success.  In the event that no
406     *         matches were located for the specified criteria, a businessList
407     *         structure with zero businessInfo structures is returned.
408     * @exception UDDIException
409     * @exception TransportException
410     * @deprecated This method has been deprecated. Use
411     * {@link #find_business(Vector, DiscoveryURLs, IdentifierBag, CategoryBag, TModelBag,
412     *                       FindQualifiers, int)} instead
413     */
414    public BusinessList find_business(DiscoveryURLs discoveryURLs,
415                                      FindQualifiers findQualifiers,
416                                      int maxRows)
417           throws UDDIException, TransportException {
418         return find_business(new Vector  (), discoveryURLs , null,  null, null,  findQualifiers, maxRows);
419     }
420 
421    /**
422     * The find_business message returns a businessList message that matches
423     * the conditions specified in the arguments.
424     * 
425     * @param names     vector of Name objects .
426     * @param discoveryURLs
427     *                  This is a list of URL's to be matched against the data associated
428     *                  with the discoveryURL's contents of registered businessEntity information.
429     *                  To search for URL without regard to useType attribute values, pass
430     *                  the useType component of the discoveryURL elements as empty attributes.
431     *                  If useType values are included, then the match will be made only on
432     *                  registered information that match both the useType and URL value.
433     *                  The returned businessList contains businessInfo structures matching
434     *                  any of the URL's passed (logical OR).
435     * @param identifierBag
436     *                  This is a list of business identifier references. The returned businessList
437     *                  contains businessInfo structures matching any of the identifiers passed
438     *                  (logical OR).
439     * @param categoryBag
440     *                   This is a list of category references.  The returned businessList
441     *                   contains businessInfo structures matching all of the categories
442     *                   passed (logical AND).
443     * @param tModelBag  The registered businessEntity data contains bindingTemplates that in turn
444     *                   contain specific tModel references.  The tModelBag argument lets you
445     *                   search for businesses that have bindings that are compatible with a
446     *                   specific tModel pattern.  The returned businessList contains businessInfo
447     *                   structures that match all of the tModel keys passed (logical AND).
448     *                   tModelKey values must be formatted as URN qualified UUID values
449     *                   (e.g. prefixed with "uuid:")
450     * @param findQualifiers
451     *                can be used to alter the default behavior of search functionality.
452     * @param maxRows allows the requesting program to limit the number of results returned.
453     * @return This function returns a businessList on success.  In the event that no
454     *         matches were located for the specified criteria, a businessList
455     *         structure with zero businessInfo structures is returned.
456     * @exception UDDIException
457     * @exception TransportException
458     */
459    public BusinessList find_business(Vector   names,
460                                      DiscoveryURLs discoveryURLs,
461                                      IdentifierBag identifierBag,
462                                      CategoryBag categoryBag,
463                                      TModelBag tModelBag,
464                                      FindQualifiers findQualifiers,
465                                      int maxRows)
466           throws UDDIException, TransportException {
467         FindBusiness request = new FindBusiness();
468         request.setNameVector(names);
469         request.setDiscoveryURLs(discoveryURLs);
470         request.setIdentifierBag(identifierBag);
471         request.setCategoryBag(categoryBag);
472         request.setTModelBag(tModelBag);
473         request.setFindQualifiers(findQualifiers);
474         if (maxRows>0) request.setMaxRows(maxRows);
475         return new BusinessList(send(request, true));
476    }
477 
478 
479    /**
480     * The find_relatedBusinesses API call is used to locate information about businessEntity
481     * registrations that are related to a specific business entity whose key is passed in the
482     * inquiry. The Related Businesses feature is used to manage registration of business units and
483     * subsequently relate them based on organizational hierarchies or business partner relationships.
484     *
485     * This  returns zero or more relatedBusinessInfo structures .For the businessEntity specified in the
486     * the response reports complete business relationships with other businessEntity
487     * registrations. Business relationships are complete between two businessEntity registrations when the
488     * publishers controlling each of the businessEntity structures involved in the relationship set
489     * assertions affirming that relationship.
490     *
491      * @param businessKey
492      *               This is used to specify a particular  BusinessEntity instance.
493      * @param keyedReference
494      *               This is a single, optional keyedReference element that is used to
495      *               specify that  only businesses that are related to the focal point
496      *               in a specific way should be included in the results.
497      * @param findQualifiers
498      *               Can be used to alter the default behavior of search functionality.
499      * @return This function returns a RelatedBusinessesList on success.
500      * @exception UDDIException
501      * @exception TransportException
502      * @deprecated UDDI version 2, errata 2 added maxrows as a parameter
503      *             to this method. Use
504      *             {@link #find_relatedBusinesses(String, KeyedReference, FindQualifiers, int)} instead
505      */
506     public RelatedBusinessesList find_relatedBusinesses(String   businessKey,
507                                                        KeyedReference keyedReference,
508                                                        FindQualifiers findQualifiers)
509           throws UDDIException, TransportException {
510        FindRelatedBusinesses request = new FindRelatedBusinesses();
511        request.setBusinessKey(businessKey);
512        request.setKeyedReference(keyedReference);
513        request.setFindQualifiers(findQualifiers);
514        return new RelatedBusinessesList(send(request, true));
515 
516    }
517 
518    /**
519     * The find_relatedBusinesses API call is used to locate information about businessEntity
520     * registrations that are related to a specific business entity whose key is passed in the
521     * inquiry. The Related Businesses feature is used to manage registration of business units and
522     * subsequently relate them based on organizational hierarchies or business partner relationships.
523     *
524     * This  returns zero or more relatedBusinessInfo structures .For the businessEntity specified in the
525     * the response reports complete business relationships with other businessEntity
526     * registrations. Business relationships are complete between two businessEntity registrations when the
527     * publishers controlling each of the businessEntity structures involved in the relationship set
528     * assertions affirming that relationship.
529     *
530     * @param businessKey      This is used to specify a particular  BusinessEntity instance.
531     *
532     * @param keyedReference   This is a single, optional keyedReference element that is used to
533     *                         specify that  only businesses that are related to the focal point
534     *                         in a specific way should be included in the results.
535     * @param findQualifiers
536     *                         Can be used to alter the default behavior of search functionality.
537     * @param maxRows          allows the requesting program to limit the number of results returned.
538     * @return This function returns a RelatedBusinessesList on success.
539     * @exception UDDIException
540     * @exception TransportException
541     */
542    public RelatedBusinessesList find_relatedBusinesses(String   businessKey,
543                                                        KeyedReference keyedReference,
544                                                        FindQualifiers findQualifiers,
545                                                        int maxRows)
546           throws UDDIException, TransportException {
547        FindRelatedBusinesses request = new FindRelatedBusinesses();
548        request.setBusinessKey(businessKey);
549        request.setKeyedReference(keyedReference);
550        request.setFindQualifiers(findQualifiers);
551        if (maxRows>0) request.setMaxRows(maxRows);
552        return new RelatedBusinessesList(send(request, true));
553 
554    }
555    /**
556     * This function returns a serviceList on success.  In the event that no
557     * matches were located for the specified criteria, the serviceList
558     * structure returned will contain an empty businessServices structure.
559     *
560     * @param businessKey
561     *                used to specify a particular  BusinessEntity instance.
562     * @param name    Represents a partial name.  Any businessService data contained in
563     *                the specified businessEntity with a matching partial name value gets returned.
564     * @param findQualifiers
565     *                Used to alter the default behavior of search functionality.
566     * @param maxRows Allows the requesting program to limit the number of results returned.
567     *                A value of 0 indicates no limit.
568     * @return This function returns a serviceList on success.  In the event that no
569     *         matches were located for the specified criteria, the serviceList
570     *         structure returned will contain an empty businessServices structure.
571     * @exception UDDIException
572     * @exception TransportException
573     * @deprecated This method has been deprecated. Use
574     * {@link #find_service(String, Vector, CategoryBag, TModelBag, FindQualifiers, int)} instead
575     *
576     */
577    public ServiceList find_service(String   businessKey,
578                                    String   name,
579                                    FindQualifiers findQualifiers,
580                                    int maxRows)
581           throws UDDIException, TransportException {
582       Vector   names = new Vector  ();
583       names.addElement(new Name(name));
584       return find_service(businessKey, names, null, null, findQualifiers, maxRows);
585    }
586 
587    /**
588     * This function returns a serviceList on success.  In the event that no
589     * matches were located for the specified criteria, the serviceList
590     * structure returned will contain an empty businessServices structure.
591     *
592     * @param businessKey
593     *                used to specify a particular  BusinessEntity instance.
594     * @param categoryBag
595     *                This is a list of category references.  The returned serviceList contains
596     *                businessInfo structures matching all of the categories passed (logical AND).
597     * @param findQualifiers
598     *                used to alter the default behavior of search functionality.
599     * @param maxRows allows the requesting program to limit the number of results returned.
600     * @return This function returns a serviceList on success.  In the event that no
601     *         matches were located for the specified criteria, the serviceList
602     *         structure returned will contain an empty businessServices structure.
603     * @exception UDDIException
604     * @exception TransportException
605     * @deprecated This method has been deprecated. Use
606     * {@link #find_service(String, Vector, CategoryBag, TModelBag, FindQualifiers, int)} instead
607     */
608    public ServiceList find_service(String   businessKey,
609                                    CategoryBag categoryBag,
610                                    FindQualifiers findQualifiers,
611                                    int maxRows)
612           throws UDDIException, TransportException {
613           return find_service(businessKey, new Vector  (), categoryBag, null, findQualifiers, maxRows);
614    }
615 
616    /**
617     * This function returns a serviceList on success.  In the event that no
618     * matches were located for the specified criteria, the serviceList
619     * structure returned will contain an empty businessServices structure.
620     *
621     * @param businessKey
622     *                This uuid_key is used to specify a particular  BusinessEntity instance.
623     * @param tModelBag
624     * @param findQualifiers
625     *                used to alter the default behavior of search functionality.
626     * @param maxRows allows the requesting program to limit the number of results returned.
627     * @return This function returns a serviceList on success.  In the event that no
628     *         matches were located for the specified criteria, the serviceList
629     *         structure returned will contain an empty businessServices structure.
630     * @exception UDDIException
631     * @exception TransportException
632     * @deprecated This method has been deprecated. Use
633     * {@link #find_service(String, Vector, CategoryBag, TModelBag, FindQualifiers, int)} instead
634     */
635    public ServiceList find_service(String   businessKey,
636                                    TModelBag tModelBag,
637                                    FindQualifiers findQualifiers,
638                                    int maxRows)
639           throws UDDIException, TransportException {
640       return find_service(businessKey, new Vector  (), null, tModelBag, findQualifiers, maxRows);
641    }
642 
643   /**
644     * This function returns a serviceList on success.  In the event that no
645     * matches were located for the specified criteria, the serviceList
646     * structure returned will contain an empty businessServices structure.
647     *
648     * @param businessKey
649     *                 This optional uuid_key is used to specify a particular
650     *                 BusinessEntity instance. This argument may be used to
651     *                 specify an existing businessEntity in the registry or
652     *                 may be specified as null or "" (empty string) to indicate
653     *                 that all businessEntities are to be searched.
654     * @param names    This optional Vector of Name objects represents one or more partial names qualified
655     *                 with xml:lang attributes.  Any businessService data contained in the specified
656     *                 businessEntity with a matching partial name value gets returned. A wildcard character %
657     *                 may be used to signify any number of any characters.  Up to 5 name values may be
658     *                 specified.  If multiple name values are passed, the match occurs on a logical OR basis
659     *                 within any names supplied (e.g. any match on name/language pairs will cause a
660     *                 registered service to be included in the final result set).
661     * @param categoryBag
662     *               : This is a list of category references.  The returned serviceList contains
663     *                 businessInfo structures matching all of the categories passed (logical AND by
664     *                 default).
665     * @param tModelBag
666     *                 This is a list of tModel uuid_key values that represent the technical fingerprint of
667     *                 a bindingTemplate structure to find. Version 2.0 defines a  way  to  associate
668     *                 businessService structures with more than one businessEntity. All bindingTemplate
669     *                 structures within any businessService associated with the businessEntity specified by
670     *                 the businessKey argument will be searched.  If more than one tModel key is specified
671     *                 in this structure, only businessService structures that contain bindingTemplate
672     *                 structures with fingerprint information that matches all of the tModel keys specified
673     *                 will be returned (logical AND only).
674     * @param findQualifiers
675     *                 used to alter the default behavior of search functionality.
676     * @param maxRows  allows the requesting program to limit the number of results returned.
677     * @return         This function returns a serviceList on success.  In the event that no
678     *                 matches were located for the specified criteria, the serviceList
679     *                 structure returned will contain an empty businessServices structure.
680     * @exception UDDIException
681     * @exception TransportException
682     */
683    public ServiceList find_service (String   businessKey,
684                                     Vector   names,
685                                     CategoryBag categoryBag,
686                                     TModelBag  tModelBag,
687                                     FindQualifiers findQualifiers,
688                                     int maxRows)
689           throws UDDIException, TransportException {
690       FindService request = new FindService();
691       request.setBusinessKey(businessKey);
692       request.setNameVector(names);
693       request.setCategoryBag(categoryBag);
694       request.setTModelBag(tModelBag);
695       request.setFindQualifiers(findQualifiers);
696       if (maxRows>0) request.setMaxRows(maxRows);
697       return new ServiceList(send(request, true));
698    }
699 
700    /**
701     * This find_tModel message is for locating a list of tModel entries
702     * that match a set of specific criteria. The response will be a list
703     * of abbreviated information about tModels that match the criteria (tModelList).
704     *
705     * @param name    This string value  represents a partial name.  The returned tModelList
706     *                contains tModelInfo structures for businesses whose name matches the
707     *                value passed (leftmost match).
708     * @param findQualifiers
709     *                used to alter the default behavior of search functionality.
710     * @param maxRows allows the requesting program to limit the number of results returned.
711     * @return This function returns a tModelList on success.  In the event that no
712     *         matches were located for the specified criteria, an empty tModelList
713     *         object will be returned (e.g. will contain zero tModelInfo objects).
714     *         This signifies zero matches
715     * @exception UDDIException
716     * @exception TransportException
717     * @deprecated This method has been deprecated. Use
718     * {@link #find_tModel(String, CategoryBag, IdentifierBag, FindQualifiers, int)} instead
719     */
720    public TModelList find_tModel(String   name,
721                                  FindQualifiers findQualifiers,
722                                  int maxRows)
723           throws UDDIException, TransportException {
724       return find_tModel(name, null, null, findQualifiers, maxRows);
725    }
726 
727    /**
728     * This find_tModel message is for locating a list of tModel entries
729     * that match a set of specific criteria. The response will be a list
730     * of abbreviated information about tModels that match the criteria (tModelList).
731     *
732     * @param categoryBag
733     *                This is a list of category references.  The returned tModelList contains
734     *                tModelInfo structures matching all of the categories passed (logical AND).
735     * @param findQualifiers
736     *                used to alter the default behavior of search functionality.
737     * @param maxRows allows the requesting program to limit the number of results returned.
738     * @return This function returns a tModelList on success.  In the event that no
739     *         matches were located for the specified criteria, an empty tModelList
740     *         object will be returned (e.g. will contain zero tModelInfo objects).
741     *         This signifies zero matches
742     * @exception UDDIException
743     * @exception TransportException
744     * @deprecated This method has been deprecated. Use
745     * {@link #find_tModel(String, CategoryBag, IdentifierBag, FindQualifiers, int)} instead
746     */
747    public TModelList find_tModel(CategoryBag categoryBag,
748                                  FindQualifiers findQualifiers,
749                                  int maxRows)
750           throws UDDIException, TransportException {
751       return find_tModel(null, categoryBag, null, findQualifiers, maxRows);
752    }
753 
754    /**
755     * This find_tModel message is for locating a list of tModel entries
756     * that match a set of specific criteria. The response will be a list
757     * of abbreviated information about tModels that match the criteria (tModelList).
758     *
759     * @param identifierBag
760     *                This is a list of business identifier references. The returned tModelList
761     *                contains tModelInfo structures matching any of the identifiers
762     *                passed (logical OR).
763     * @param findQualifiers
764     *                used to alter the default behavior of search functionality.
765     * @param maxRows allows the requesting program to limit the number of results returned.
766     * @return This function returns a tModelList on success.  In the event that no
767     *         matches were located for the specified criteria, an empty tModelList
768     *         object will be returned (e.g. will contain zero tModelInfo objects).
769     *         This signifies zero matches.
770     * @exception UDDIException
771     * @exception TransportException
772     * @deprecated This method has been deprecated. Use
773     * {@link #find_tModel(String, CategoryBag, IdentifierBag, FindQualifiers, int)} instead
774     */
775    public TModelList find_tModel(IdentifierBag identifierBag,
776                                  FindQualifiers findQualifiers,
777                                  int maxRows)
778           throws UDDIException, TransportException {
779       return find_tModel(null, null, identifierBag, findQualifiers, maxRows);
780    }
781 
782   /**
783     * This find_tModel message is for locating a list of tModel entries
784     * that match a set of specific criteria. The response will be a list
785     * of abbreviated information about tModels that match the criteria (tModelList).
786     *
787     * @param name    This string value  represents a partial name.  Since tModel data only has a single name,
788     *                only a single name may be passed.  A wildcard character % may be used to signify any
789     *                number of any characters. The returned tModelList contains tModelInfo elements for
790     *                tModels whose name matches the value passed (via lexical-order - i.e., leftmost in
791     *                left-to-right languages - partial match or wild card treatment).
792     *
793     * @param categoryBag
794     *                This is a list of category references.  The returned tModelList contains tModelInfo
795     *                elements matching all of the categories passed (logical AND by default).  FindQualifier
796     *                can be used to alter this logical AND behavior.
797     * @param identifierBag
798     *                This is a list of business identifier references. The returned tModelList
799     *                contains tModelInfo structures matching any of the identifiers
800     *                passed (logical OR).
801     * @param findQualifiers
802     *                used to alter the default behavior of search functionality.
803     * @param maxRows allows the requesting program to limit the number of results returned.
804     * @return This function returns a tModelList on success.  In the event that no
805     *         matches were located for the specified criteria, an empty tModelList
806     *         object will be returned (e.g. will contain zero tModelInfo objects).
807     *         This signifies zero matches.
808     * @exception UDDIException
809     * @exception TransportException
810     */
811    public TModelList find_tModel (String   name,
812                                    CategoryBag categoryBag,
813                                    IdentifierBag identifierBag,
814                                    FindQualifiers findQualifiers,
815                                    int maxRows)
816           throws UDDIException, TransportException {
817       FindTModel request = new FindTModel();
818       request.setName(name);
819       request.setCategoryBag(categoryBag);
820       request.setIdentifierBag(identifierBag);
821       request.setFindQualifiers(findQualifiers);
822       if (maxRows>0) request.setMaxRows(maxRows);
823       return new TModelList(send(request, true));
824    }
825 
826 
827    /**
828     * The get_bindingDetail message is for requesting the run-time
829     * bindingTemplate information location information for the purpose of
830     * invoking a registered business API.
831     *
832     * @param bindingKey uuid_key string that represent specific instance
833     *                   of known bindingTemplate data.
834     * @return This function returns a bindingDetail message on successful match
835     * @exception UDDIException
836     * @exception TransportException
837     */
838    public BindingDetail get_bindingDetail(String   bindingKey)
839           throws UDDIException, TransportException {
840       GetBindingDetail request = new GetBindingDetail();
841       Vector   keys = new Vector  ();
842       keys.addElement(bindingKey);
843       request.setBindingKeyStrings(keys);
844       return new BindingDetail(send(request, true));
845    }
846 
847    /**
848     * The get_bindingDetail message is for requesting the run-time
849     * bindingTemplate information location information for the purpose of
850     * invoking a registered business API.
851     *
852     * @param bindingKeyStrings Vector of uuid_key strings that represent specific instances
853     *                   of known bindingTemplate data.
854     * @return This function returns a bindingDetail message on successful match of one
855     *         or more bindingKey values.  If multiple bindingKey values were passed, the
856     *         results will be returned in the same order as the keys passed.
857     * @exception UDDIException
858     * @exception TransportException
859     */
860    public BindingDetail get_bindingDetail(Vector   bindingKeyStrings)
861           throws UDDIException, TransportException {
862       GetBindingDetail request = new GetBindingDetail();
863       request.setBindingKeyStrings(bindingKeyStrings);
864       return new BindingDetail(send(request, true));
865    }
866 
867    /**
868     * The get_businessDetail message returns complete businessEntity information
869     * for one or more specified businessEntitys
870     *
871     * @param businessKey
872     *               A uuid_key string that represents a specific instance of known
873     *               businessEntity data.
874     * @return This function returns a businessDetail object on successful match
875     *         of one or more businessKey values.  If multiple businessKey values
876     *         were passed, the results will be returned in the same order as the
877     *         keys passed.
878     * @exception UDDIException
879     * @exception TransportException
880     */
881    public BusinessDetail get_businessDetail(String   businessKey)
882           throws UDDIException, TransportException {
883       GetBusinessDetail request = new GetBusinessDetail();
884       Vector   keys = new Vector  ();
885       keys.addElement(businessKey);
886       request.setBusinessKeyStrings(keys);
887       return new BusinessDetail(send(request, true));
888    }
889    /**
890     * The get_businessDetail message returns complete businessEntity information
891     * for one or more specified businessEntitys
892     *
893     * @param businessKeyStrings
894     *               Vector of uuid_key strings that represent specific instances of known
895     *               businessEntity data.
896     * @return This function returns a businessDetail message on successful match
897     *         of one or more businessKey values.  If multiple businessKey values
898     *         were passed, the results will be returned in the same order as the
899     *         keys passed.
900     * @exception UDDIException
901     * @exception TransportException
902     */
903    public BusinessDetail get_businessDetail(Vector   businessKeyStrings)
904           throws UDDIException, TransportException {
905       GetBusinessDetail request = new GetBusinessDetail();
906       request.setBusinessKeyStrings(businessKeyStrings);
907       return new BusinessDetail(send(request, true));
908    }
909 
910    /**
911     * The get_businessDetailExt message returns extended businessEntity
912     * information for one or more specified businessEntitys.  This
913     * message returns exactly the same information as the get_businessDetail
914     * message, but may contain additional attributes if the source is
915     * an external registry (not an Operator Site) that is compatible
916     * with this API specification.
917     *
918     * @param businessKey
919     *               A uuid_key string that represents a specific instance of known
920     *               businessEntity data.
921     * @return This function returns a businessDetailExt message on successful match
922     *         of one or more businessKey values.  If multiple businessKey values
923     *         were passed, the results will be returned in the same order as the
924     *         keys passed.
925     * @exception UDDIException
926     * @exception TransportException
927     */
928    public BusinessDetailExt get_businessDetailExt(String   businessKey)
929           throws UDDIException, TransportException {
930       GetBusinessDetailExt request = new GetBusinessDetailExt();
931       Vector   keys = new Vector  ();
932       keys.addElement(businessKey);
933       request.setBusinessKeyStrings(keys);
934       return new BusinessDetailExt(send(request, true));
935    }
936    /**
937     * The get_businessDetailExt message returns extended businessEntity
938     * information for one or more specified businessEntitys.  This
939     * message returns exactly the same information as the get_businessDetail
940     * message, but may contain additional attributes if the source is
941     * an external registry (not an Operator Site) that is compatible
942     * with this API specification.
943     *
944     * @param businessKeyStrings
945     *               Vector of uuid_key strings that represent specific instances of known
946     *               businessEntity data.
947     * @return This function returns a businessDetailExt message on successful match
948     *         of one or more businessKey values.  If multiple businessKey values
949     *         were passed, the results will be returned in the same order as the
950     *         keys passed.
951     * @exception UDDIException
952     * @exception TransportException
953     */
954    public BusinessDetailExt get_businessDetailExt(Vector   businessKeyStrings)
955           throws UDDIException, TransportException {
956       GetBusinessDetailExt request = new GetBusinessDetailExt();
957       request.setBusinessKeyStrings(businessKeyStrings);
958       return new BusinessDetailExt(send(request, true));
959    }
960 
961    /**
962     * The get_serviceDetail message is used to request full information
963     * about a known businessService structure.
964     *
965     * @param serviceKey A uuid_key string that represents a specific instance of
966     *                   known businessService data.
967     * @return This function returns a serviceDetail message on successful match
968     *         of one or more serviceKey values.  If multiple serviceKey values
969     *         were passed, the results will be returned in the same order as the
970     *         keys passed.
971     * @exception UDDIException
972     * @exception TransportException
973     */
974    public ServiceDetail get_serviceDetail(String   serviceKey)
975           throws UDDIException, TransportException {
976       GetServiceDetail request = new GetServiceDetail();
977       Vector   keys = new Vector  ();
978       keys.addElement(serviceKey);
979       request.setServiceKeyStrings(keys);
980       return new ServiceDetail(send(request, true));
981    }
982 
983    /**
984     * The get_serviceDetail message is used to request full information
985     * about a known businessService structure.
986     *
987     * @param serviceKeyStrings
988     *               A vector of uuid_key strings that represent specific instances of
989     *               known businessService data.
990     * @return This function returns a serviceDetail message on successful match
991     *         of one or more serviceKey values.  If multiple serviceKey values
992     *         were passed, the results will be returned in the same order as the
993     *         keys passed.
994     * @exception UDDIException
995     * @exception TransportException
996     */
997    public ServiceDetail get_serviceDetail(Vector   serviceKeyStrings)
998           throws UDDIException, TransportException {
999       GetServiceDetail request = new GetServiceDetail();
1000      request.setServiceKeyStrings(serviceKeyStrings);
1001      return new ServiceDetail(send(request, true));
1002   }
1003
1004   /**
1005    * The get_tModelDetail message is used to request full information
1006    * about a known tModel structure.
1007    *
1008    * @param tModelKey A URN qualified uuid_key string that represent a specific
1009    *                  instance of known tModel data.  All tModelKey values begin with a
1010    *                  uuid URN qualifier (e.g. "uuid:" followed by a known tModel UUID value.)
1011    * @return This function returns a tModelDetail message on successful match
1012    *         of one or more tModelKey values.  If multiple tModelKey values
1013    *         were passed, the results will be returned in the same order as
1014    *         the keys passed.
1015    * @exception UDDIException
1016    * @exception TransportException
1017    */
1018   public TModelDetail get_tModelDetail(String   tModelKey)
1019          throws UDDIException, TransportException {
1020      GetTModelDetail request = new GetTModelDetail();
1021      Vector   keys = new Vector  ();
1022      keys.addElement(tModelKey);
1023      request.setTModelKeyStrings(keys);
1024      return new TModelDetail(send(request, true));
1025   }
1026
1027   /**
1028    * The get_tModelDetail message is used to request full information
1029    * about a known tModel structure.
1030    *
1031    * @param tModelKeyStrings
1032    *               A Vector of URN qualified uuid_key strings that represent specific
1033    *               instances of known tModel data.  All tModelKey values begin with a
1034    *               uuid URN qualifier (e.g. "uuid:" followed by a known tModel UUID value.)
1035    * @return This function returns a tModelDetail message on successful match
1036    *         of one or more tModelKey values.  If multiple tModelKey values
1037    *         were passed, the results will be returned in the same order as
1038    *         the keys passed.
1039    * @exception UDDIException
1040    * @exception TransportException
1041    */
1042   public TModelDetail get_tModelDetail(Vector   tModelKeyStrings)
1043          throws UDDIException, TransportException {
1044      GetTModelDetail request = new GetTModelDetail();
1045      request.setTModelKeyStrings(tModelKeyStrings);
1046      return new TModelDetail(send(request, true));
1047   }
1048
1049   /**
1050    * The add_publisherAssertions message is used to add relationship assertions to the
1051    * existing set of assertions.
1052    *
1053    * @param authInfo     Contains an authentication token. Authentication tokens are obtained
1054    *                     using the get_authToken method.
1055    * @param publisherAssertion    Contains a relationship assertion.
1056    * @return    This function returns a  DispositionReport with a single success indicator.
1057    * @exception UDDIException
1058    * @exception TransportException
1059    */
1060   public  DispositionReport add_publisherAssertions (String   authInfo,
1061                                                     PublisherAssertion publisherAssertion)
1062          throws UDDIException, TransportException {
1063      Vector   pubVector = new Vector  ();
1064      pubVector.addElement(publisherAssertion);
1065      return add_publisherAssertions (authInfo, pubVector);
1066   }
1067
1068   /**
1069    * The add_publisherAssertions message is used to add relationship assertions to the
1070    * existing set of assertions.
1071    *
1072    * @param authInfo     Contains an authentication token. Authentication tokens are obtained
1073    *                     using the get_authToken method.
1074    * @param publisherAssertion    Vector of publisherAssertion object. Each publisherAssertion
1075    *                              contains a relationship assertion.
1076    * @return   This function returns a  DispositionReport with a single success indicator.
1077    * @exception UDDIException
1078    * @exception TransportException
1079    */
1080   public  DispositionReport add_publisherAssertions (String   authInfo,
1081                                                     Vector   publisherAssertion)
1082          throws UDDIException, TransportException {
1083      AddPublisherAssertions request = new  AddPublisherAssertions();
1084      request.setAuthInfo(authInfo);
1085      request.setPublisherAssertionVector(publisherAssertion);
1086      return new DispositionReport(send(request, false));
1087
1088   }
1089
1090   /**
1091     * The get_assertionStatusReport message is used to request a status
1092     * report containing publisher assertions and status information.  This contains
1093     * all complete and incomplete  assertions and serves an administrative use including
1094     * the determination if there are any outstanding, incomplete assertions about relationships
1095     * involving businesses the publisher account is associated with.
1096     *
1097     * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1098     *                    using the get_authToken method.
1099     * @param completionStatus    This argument (String) lets the publisher restrict the result set
1100     *                            to only those relationships that have the status value specified.
1101     * @return    Upon successful completion, an assertionStatusReport message is returned
1102     *            containing assertion status information.
1103     * @exception UDDIException
1104     * @exception TransportException
1105     */
1106      public AssertionStatusReport get_assertionStatusReport(String   authInfo,
1107                                                             String   completionStatus)
1108             throws UDDIException, TransportException {
1109         return get_assertionStatusReport(authInfo, new CompletionStatus(completionStatus));
1110      }
1111
1112   /**
1113    * The get_assertionStatusReport message is used to request a status
1114    * report containing publisher assertions and status information. This contains
1115    * all complete and incomplete  assertions and serves an administrative use including
1116    * the determination if there are any outstanding, incomplete assertions about relationships
1117    * involving businesses the publisher account is associated with.
1118    *
1119    * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1120    *                    using the get_authToken method.
1121    * @param completionStatus   This argument lets the publisher restrict the result set to
1122    *                           only those relationships that have the status value specified.
1123    * @return    Upon successful completion, an assertionStatusReport message is returned
1124    *            containing assertion status information.
1125    * @exception UDDIException
1126    * @exception TransportException
1127    */
1128   public AssertionStatusReport get_assertionStatusReport(String   authInfo,
1129                                                          CompletionStatus completionStatus)
1130          throws UDDIException, TransportException {
1131      GetAssertionStatusReport request = new GetAssertionStatusReport();
1132      request.setAuthInfo(authInfo);
1133      request.setCompletionStatus(completionStatus);
1134      return new AssertionStatusReport(send(request, false));
1135   }
1136
1137
1138   /**
1139    * The get_publisherAssertions message is used to get a list of active
1140    * publisher assertions that are controlled by an individual publisher account.
1141    *
1142    * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1143    *                    using the get_authToken method.
1144    * @return This function returns a PublisherAssertions message that contains a
1145    *         publisherAssertion element for each publisher assertion registered by the
1146    *         publisher account associated with the authentication information.
1147    * @exception UDDIException
1148    * @exception TransportException
1149    */
1150   public PublisherAssertions get_publisherAssertions(String   authInfo)
1151          throws UDDIException, TransportException {
1152      GetPublisherAssertions request = new GetPublisherAssertions();
1153      request.setAuthInfo(authInfo);
1154      return new PublisherAssertions(send(request, false));
1155   }
1156
1157   /**
1158    * The delete_binding message causes one or more bindingTemplate to be deleted.
1159    *
1160    * @param authInfo   Contains an authentication token. Authentication tokens are obtained
1161    *                   using the get_authToken method.
1162    * @param bindingKey A uuid_key value that represents a specific instance of
1163    *                   known bindingTemplate data.
1164    * @return Upon successful completion, a dispositionReport is returned with a
1165    *         single success indicator.
1166    * @exception UDDIException
1167    * @exception TransportException
1168    */
1169   public DispositionReport delete_binding(String   authInfo,
1170                                           String   bindingKey)
1171          throws UDDIException, TransportException {
1172      DeleteBinding request = new DeleteBinding();
1173      request.setAuthInfo(authInfo);
1174      Vector   keys = new Vector  ();
1175      keys.addElement(bindingKey);
1176      request.setBindingKeyStrings(keys);
1177      return new DispositionReport(send(request, false));
1178   }
1179
1180   /**
1181    * The delete_binding message causes one or more bindingTemplate to be deleted.
1182    *
1183    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1184    *                 using the get_authToken method.
1185    * @param bindingKeyStrings
1186    *                 A vector of uuid_key strings that represents specific instances of
1187    *                 known bindingTemplate data.
1188    * @return Upon successful completion, a dispositionReport is returned with a
1189    *         single success indicator
1190    * @exception UDDIException
1191    * @exception TransportException
1192    */
1193   public DispositionReport delete_binding(String   authInfo,
1194                                           Vector   bindingKeyStrings)
1195          throws UDDIException, TransportException {
1196      DeleteBinding request = new DeleteBinding();
1197      request.setAuthInfo(authInfo);
1198      request.setBindingKeyStrings(bindingKeyStrings);
1199      return new DispositionReport(send(request, false));
1200   }
1201
1202   /**
1203    * The delete_business message is used to remove one or more
1204    * businessEntity structures.
1205    *
1206    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1207    *                 using the get_authToken method.
1208    * @param businessKey
1209    *                 Uuid_key string that represents specific instance of known
1210    *                 businessEntity data.
1211    * @return Upon successful completion, a dispositionReport is returned with a
1212    *         single success indicator
1213    * @exception UDDIException
1214    * @exception TransportException
1215    */
1216   public DispositionReport delete_business(String   authInfo,
1217                                            String   businessKey)
1218          throws UDDIException, TransportException {
1219      DeleteBusiness request = new DeleteBusiness();
1220      request.setAuthInfo(authInfo);
1221      Vector   keys = new Vector  ();
1222      keys.addElement(businessKey);
1223      request.setBusinessKeyStrings(keys);
1224      return new DispositionReport(send(request, false));
1225   }
1226
1227   /**
1228    * The delete_business message is used to remove one or more
1229    * businessEntity structures.
1230    *
1231    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1232    *                 using the get_authToken method.
1233    * @param businessKeyStrings
1234    *                 Vector of uuid_key strings that represent specific instances of known
1235    *                 businessEntity data.
1236    * @return Upon successful completion, a dispositionReport is returned with a
1237    *         single success indicator
1238    * @exception UDDIException
1239    * @exception TransportException
1240    */
1241   public DispositionReport delete_business(String   authInfo,
1242                                            Vector   businessKeyStrings)
1243          throws UDDIException, TransportException {
1244      DeleteBusiness request = new DeleteBusiness();
1245      request.setAuthInfo(authInfo);
1246      request.setBusinessKeyStrings(businessKeyStrings);
1247      return new DispositionReport(send(request, false));
1248   }
1249
1250   /**
1251    * The delete_service message is used to remove one or more
1252    * businessService structures.
1253    *
1254    * @param authInfo   Contains an authentication token. Authentication tokens are obtained
1255    *                   using the get_authToken method.
1256    * @param serviceKey uuid_key string that represents specific instance of known
1257    *                   businessService data.
1258    * @return Upon successful completion, a dispositionReport is returned with a
1259    *         single success indicator
1260    * @exception UDDIException
1261    * @exception TransportException
1262    */
1263   public DispositionReport delete_service(String   authInfo,
1264                                           String   serviceKey)
1265          throws UDDIException, TransportException {
1266      DeleteService request = new DeleteService();
1267      request.setAuthInfo(authInfo);
1268      Vector   keys = new Vector  ();
1269      keys.addElement(serviceKey);
1270      request.setServiceKeyStrings(keys);
1271      return new DispositionReport(send(request, false));
1272   }
1273
1274   /**
1275    * The delete_service message is used to remove one or more
1276    * businessService structures.
1277    *
1278    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1279    *                 using the get_authToken method.
1280    * @param serviceKeyStrings
1281    *                 Vector of uuid_key strings that represent specific instances of known
1282    *                 businessService data.
1283    * @return Upon successful completion, a dispositionReport is returned with a
1284    *         single success indicator
1285    * @exception UDDIException
1286    * @exception TransportException
1287    */
1288   public DispositionReport delete_service(String   authInfo,
1289                                           Vector   serviceKeyStrings)
1290          throws UDDIException, TransportException {
1291      DeleteService request = new DeleteService();
1292      request.setAuthInfo(authInfo);
1293      request.setServiceKeyStrings(serviceKeyStrings);
1294      return new DispositionReport(send(request, false));
1295   }
1296
1297   /**
1298    * The delete_tModel message is used to remove or retire one or more
1299    * tModel structures.
1300    *
1301    * @param authInfo  Contains an authentication token. Authentication tokens are obtained
1302    *                  using the get_authToken method.
1303    * @param tModelKey uuid_key string that represents specific instance of known
1304    *                  tModel data.
1305    * @return Upon successful completion, a dispositionReport is returned with a
1306    *         single success indicator
1307    * @exception UDDIException
1308    * @exception TransportException
1309    */
1310   public DispositionReport delete_tModel(String   authInfo,
1311                                          String   tModelKey)
1312          throws UDDIException, TransportException {
1313      DeleteTModel request = new DeleteTModel();
1314      request.setAuthInfo(authInfo);
1315      Vector   keys = new Vector  ();
1316      keys.addElement(tModelKey);
1317      request.setTModelKeyStrings(keys);
1318      return new DispositionReport(send(request, false));
1319   }
1320
1321   /**
1322    * The delete_tModel message is used to remove or retire one or more
1323    * tModel structures.
1324    *
1325    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1326    *                 using the get_authToken method.
1327    * @param tModelKeyStrings
1328    *                 Vector of uuid_key strings that represent specific instances of known
1329    *                 tModel data.
1330    * @return Upon successful completion, a dispositionReport is returned with a
1331    *         single success indicator
1332    * @exception UDDIException
1333    * @exception TransportException
1334    */
1335   public DispositionReport delete_tModel(String   authInfo,
1336                                          Vector   tModelKeyStrings)
1337          throws UDDIException, TransportException {
1338      DeleteTModel request = new DeleteTModel();
1339      request.setAuthInfo(authInfo);
1340      request.setTModelKeyStrings(tModelKeyStrings);
1341      return new DispositionReport(send(request, false));
1342   }
1343
1344   /**
1345    * The delete_publisherAssertions message is used to delete specific publisher assertions
1346    * from the assertion collection controlled by a particular publisher account. Deleting assertions from
1347    * the assertion collection will affect the visibility of business relationships.  Deleting an assertion
1348    * will cause any relationships based on that assertion to be invalidated.
1349    *
1350    * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1351    *                    using the get_authToken method.
1352    * @param publisherAssertion   Contains a relationship assertion.
1353    *
1354    * @return Upon successful completion, a dispositionReport is returned with a
1355    *         single success indicator
1356    * @exception UDDIException
1357    * @exception TransportException
1358    */
1359   public DispositionReport delete_publisherAssertions(String   authInfo,
1360                                                        PublisherAssertion publisherAssertion)
1361          throws UDDIException, TransportException {
1362      Vector   pubVector = new Vector  ();
1363      pubVector.addElement(publisherAssertion);
1364      return delete_publisherAssertions(authInfo, pubVector);
1365   }
1366
1367   /**
1368    * The delete_publisherAssertions message is used to delete specific publisher assertions
1369    * from the assertion collection controlled by a particular publisher account. Deleting assertions from
1370    * the assertion collection will affect the visibility of business relationships.  Deleting an assertion
1371    * will cause any relationships based on that assertion to be invalidated.
1372    *
1373    * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1374    *                    using the get_authToken method.
1375    * @param publisherAssertion   Is a vector of publisherAssertion values. Each publisherAssertion
1376    *                             contains a relationship assertion.
1377    * @return Upon successful completion, a dispositionReport is returned with a
1378    *         single success indicator
1379    * @exception UDDIException
1380    * @exception TransportException
1381    */
1382   public DispositionReport delete_publisherAssertions(String   authInfo,
1383                                                       Vector   publisherAssertion)
1384          throws UDDIException, TransportException {
1385      DeletePublisherAssertions request = new DeletePublisherAssertions();
1386      request.setAuthInfo(authInfo);
1387      request.setPublisherAssertionVector(publisherAssertion);
1388      return new DispositionReport(send(request, false));
1389   }
1390
1391   /**
1392    * The discard_authToken message is used to inform an Operator Site that the
1393    * authentication token can be discarded.  Subsequent calls that use the
1394    * same authToken may be rejected.  This message is optional for Operator
1395    * Sites that do not manage session state or that do not support the
1396    * get_authToken message.
1397    *
1398    * @param authInfo Contains an String authentication token. Authentication tokens are obtained
1399    *                 using the get_authToken method.
1400    * @return Upon successful completion, a dispositionReport is returned with a
1401    *         single success indicator.  Discarding an expired authToken will be
1402    *         processed and reported as a success condition.
1403    * @exception UDDIException
1404    * @exception TransportException
1405    */
1406   public DispositionReport discard_authToken(String   authInfo)
1407          throws UDDIException, TransportException {
1408      DiscardAuthToken request = new DiscardAuthToken();
1409      request.setAuthInfo(authInfo);
1410      return new DispositionReport(send(request, false));
1411   }
1412   /**
1413    * The discard_authToken message is used to inform an Operator Site that the
1414    * authentication token can be discarded.  Subsequent calls that use the
1415    * same authToken may be rejected.  This message is optional for Operator
1416    * Sites that do not manage session state or that do not support the
1417    * get_authToken message.
1418    *
1419    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1420    *                 using the get_authToken method.
1421    * @return Upon successful completion, a dispositionReport is returned with a
1422    *         single success indicator.  Discarding an expired authToken will be
1423    *         processed and reported as a success condition.
1424    * @exception UDDIException
1425    * @exception TransportException
1426    */
1427   public DispositionReport discard_authToken(AuthInfo authInfo)
1428          throws UDDIException, TransportException {
1429      DiscardAuthToken request = new DiscardAuthToken();
1430      request.setAuthInfo(authInfo);
1431      return new DispositionReport(send(request, false));
1432   }
1433
1434   /**
1435    * The get_authToken message is used to obtain an authentication token.
1436    * Authentication tokens are opaque values that are required for all
1437    * other publisher API calls.  This message is not required for Operator
1438    * Sites that have an external mechanism defined for users to get an
1439    * authentication token.  This API is provided for implementations that
1440    * do not have some other method of obtaining an authentication token or
1441    * certificate, or that choose to use userID and Password based authentication.
1442    *
1443    * @param userid user that an individual authorized user was assigned by an Operator Site.
1444    *               Operator Sites will each provide a way for individuals to obtain a UserID
1445    *               and password that will be valid only at the given Operator Site.
1446    * @param cred   password or credential that is associated with the user.
1447    * @return This function returns an authToken object that contains a valid
1448    *         authInfo object that can be used in subsequent calls to publisher
1449    *         API calls that require an authInfo value.
1450    * @exception UDDIException
1451    * @exception TransportException
1452    */
1453   public AuthToken get_authToken(String   userid,
1454                                  String   cred)
1455          throws UDDIException, TransportException {
1456      GetAuthToken request = new GetAuthToken();
1457      request.setUserID(userid);
1458      request.setCred(cred);
1459      return new AuthToken(send(request, false));
1460   }
1461
1462
1463   /**
1464    * The get_registeredInfo message is used to get an abbreviated list
1465    * of all businessEntity keys and tModel keys that are controlled by
1466    * the individual associated the credentials passed.
1467    *
1468    * @param authInfo Contains an authentication token.  Authentication tokens are obtained
1469    *                 using the get_authToken API call.
1470    * @return Upon successful completion, a registeredInfo object will be returned,
1471    *         listing abbreviated business information in one or more businessInfo
1472    *         objects, and tModel information in one or more tModelInfo objects.
1473    *         This API is useful for determining the full extent of registered
1474    *         information controlled by a single user in a single call.
1475    * @exception UDDIException
1476    * @exception TransportException
1477    */
1478   public RegisteredInfo get_registeredInfo(String   authInfo)
1479          throws UDDIException, TransportException {
1480      GetRegisteredInfo request = new GetRegisteredInfo();
1481      request.setAuthInfo(authInfo);
1482      return new RegisteredInfo(send(request, false));
1483   }
1484
1485   /**
1486    * The save_binding message is used to save or update a complete
1487    * bindingTemplate structure.  This message can be used to add or
1488    * update one or more bindingTemplate structures to one or more existing
1489    * businessService structures.
1490    *
1491    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1492    *                 using the get_authToken method.
1493    * @param bindingTemplates
1494    *                 Vector of bindingTemplate objects.  The order in which these are
1495    *                 processed is not defined.  To save a new bindingTemplate, pass a
1496    *                 bindingTemplate object with an empty bindingKey attribute value.
1497    * @return This API returns a bindingDetail object containing the final results
1498    *         of the call that reflects the newly registered information for the
1499    *         effected bindingTemplate objects.
1500    * @exception UDDIException
1501    * @exception TransportException
1502    */
1503   public BindingDetail save_binding(String   authInfo,
1504                                     Vector   bindingTemplates)
1505          throws UDDIException, TransportException {
1506      SaveBinding request = new SaveBinding();
1507      request.setAuthInfo(authInfo);
1508      request.setBindingTemplateVector(bindingTemplates);
1509      return new BindingDetail(send(request, false));
1510   }
1511
1512   /**
1513    * The save_business message is used to save or update information about a
1514    * complete businessEntity structure.  This API has the broadest scope of
1515    * all of the save_x API calls in the publisher API, and can be used to make
1516    * sweeping changes to the published information for one or more
1517    * businessEntity structures controlled by an individual.
1518    *
1519    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1520    *                 using the get_authToken method.
1521    * @param businessEntities
1522    *                 Vector of businessEntity objects.  These objects can be obtained in advance
1523    *                 by using the get_businessDetail API call or by any other means.
1524    * @return This API returns a businessDetail message containing the final results
1525    *         of the call that reflects the new registered information for the
1526    *         businessEntity information provided.
1527    * @exception UDDIException
1528    * @exception TransportException
1529    */
1530   public BusinessDetail save_business(String   authInfo,
1531                                       Vector   businessEntities)
1532          throws UDDIException, TransportException {
1533      SaveBusiness request = new SaveBusiness();
1534      request.setAuthInfo(authInfo);
1535      request.setBusinessEntityVector(businessEntities);
1536      return new BusinessDetail(send(request, false));
1537   }
1538   /**
1539    * The save_business message is used to save or update information about a
1540    * complete businessEntity structure.  This API has the broadest scope of
1541    * all of the save_x API calls in the publisher API, and can be used to make
1542    * sweeping changes to the published information for one or more
1543    * businessEntity structures controlled by an individual.
1544    *
1545    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1546    *                 using the get_authToken method.
1547    * @param uploadRegisters
1548    *                 Vector of UpLoadRegister objects which contain resolvable HTTP URL
1549    *                 addresses that each point to a single and valid businessEntity
1550    *                 or businessEntityExt structure.  This allows a registry to be updated
1551    *                 to reflect the contents of an XML document that is URL addressable.
1552    *                 The URL must return a pure XML document that only contains a
1553    *                 businessEntity structure as its top-level element, and be accessible
1554    *                 using the standard HTTP-GET protocol.
1555    * @return This API returns a businessDetail message containing the final results
1556    *         of the call that reflects the new registered information for the
1557    *         businessEntity information provided.
1558    * @exception UDDIException
1559    * @exception TransportException
1560    * @deprecated This method has been deprecated. Use
1561    * {@link #save_business(String, Vector)} instead
1562    */
1563   public BusinessDetail save_business(String   authInfo,
1564                                       UploadRegister[] uploadRegisters)
1565          throws UDDIException, TransportException {
1566      SaveBusiness request = new SaveBusiness();
1567      Vector   keys = new Vector  ( Arrays.asList(uploadRegisters) );
1568      request.setAuthInfo(authInfo);
1569      request.setUploadRegisterVector(keys);
1570      return new BusinessDetail(send(request, false));
1571   }
1572
1573
1574   /**
1575    * The save_service message adds or updates one or more businessService
1576    * structures.
1577    *
1578    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1579    *                 using the get_authToken method.
1580    * @param businessServices
1581    *                 Vector of businessService objects.  These objects can be obtained in
1582    *                 advance by using the get_serviceDetail API call or by any other means.
1583    * @return This API returns a serviceDetail object containing the final results
1584    *         of the call that reflects the newly registered information for the
1585    *         effected businessService structures.
1586    * @exception UDDIException
1587    * @exception TransportException
1588    */
1589   public ServiceDetail save_service(String   authInfo,
1590                                     Vector   businessServices)
1591          throws UDDIException, TransportException {
1592      SaveService request = new SaveService();
1593      request.setAuthInfo(authInfo);
1594      request.setBusinessServiceVector(businessServices);
1595      return new ServiceDetail(send(request, false));
1596   }
1597
1598   /**
1599    * The save_tModel message adds or updates one or more tModel structures.
1600    *
1601    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1602    *                 using the get_authToken method.
1603    * @param tModels  Vector of complete tModel structures.  If adding a new tModel,
1604    *                 the tModelKey value should be passed as an empty element.
1605    * @return This API returns a tModelDetail message containing the final results
1606    *         of the call that reflects the new registered information for the
1607    *         effected tModel structures
1608    * @exception UDDIException
1609    * @exception TransportException
1610    */
1611   public TModelDetail save_tModel(String   authInfo,
1612                                   Vector   tModels)
1613          throws UDDIException, TransportException {
1614      SaveTModel request = new SaveTModel();
1615      request.setAuthInfo(authInfo);
1616      request.setTModelVector(tModels);
1617      return new TModelDetail(send(request, false));
1618   }
1619
1620   /**
1621    * The save_tModel message adds or updates one or more tModel structures.
1622    *
1623    * @param authInfo Contains an authentication token. Authentication tokens are obtained
1624    *                 using the get_authToken method.
1625    * @param uploadRegisters
1626    *                 Vector of UploadRegister objects that contain resolvable HTTP URL
1627    *                 addresses that each point to a single and valid tModel structure.
1628    *                 This allows a registry to be updated to reflect the contents of
1629    *                 an XML document that is URL addressable.  The URL must return a
1630    *                 pure XML document that only contains a tModel structure as its
1631    *                 top-level element, and be accessible using the standard HTTP-GET protocol.
1632    * @return This API returns a tModelDetail message containing the final results
1633    *         of the call that reflects the new registered information for the
1634    *         effected tModel structures
1635    * @exception UDDIException
1636    * @exception TransportException
1637    * @deprecated This method has been deprecated. Use
1638    * {@link #save_tModel(String, Vector)} instead
1639    */
1640   public TModelDetail save_tModel(String   authInfo,
1641                                   UploadRegister[] uploadRegisters)
1642          throws UDDIException, TransportException {
1643      SaveTModel request = new SaveTModel();
1644      request.setAuthInfo(authInfo);
1645      Vector   keys = new Vector  ( Arrays.asList(uploadRegisters) );
1646      request.setUploadRegisterVector(keys);
1647      return new TModelDetail(send(request, false));
1648   }
1649   /**
1650    * The set_publisherAssertions message is used to save the complete set of publisher
1651    * assertions for an individual publisher account. When this message is processed, the publisher
1652    * assertions that are active prior to this API call for a given publisher account are examined by the
1653    * UDDI registry. Any new assertions not present prior to the call are added to the assertions attributed
1654    * to the publisher. As a result, new relationships may be activated (e.g. determined to have a completed
1655    * status), and existing relationships may be deactivated.
1656    *
1657    * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1658    *                    using the get_authToken method.
1659    * @param pub     Contains a relationship assertion.
1660    * @return   Upon successful completion, a publisherAssertions message is returned containing
1661    *           all of the relationship assertions currently attributed to the publisher account
1662    *           that is associated with the authInfo data passed.
1663    * @exception UDDIException
1664    * @exception TransportException
1665    */
1666   public PublisherAssertions set_publisherAssertions (String    authInfo,
1667                                                       PublisherAssertion  pub)
1668          throws UDDIException, TransportException {
1669      Vector   pubVector = new Vector  ();
1670      pubVector.addElement(pub);
1671      return set_publisherAssertions(authInfo,pubVector);
1672    }
1673
1674   /**
1675    * The set_publisherAssertions message is used to save the complete set of publisher
1676    * assertions for an individual publisher account. When this message is processed, the publisher
1677    * assertions that are active prior to this API call for a given publisher account are examined by the
1678    * UDDI registry. Any new assertions not present prior to the call are added to the assertions attributed
1679    * to the publisher. As a result, new relationships may be activated (e.g. determined to have a completed
1680    * status), and existing relationships may be deactivated.
1681    *
1682    * @param authInfo    Contains an authentication token. Authentication tokens are obtained
1683    *                    using the get_authToken method.
1684    * @param publisherAssertion    Is a vector of publisherAssertion object. Each publisherAssertion
1685    *                              contains a relationship assertion.
1686    * @return   Upon successful completion, a publisherAssertions message is returned containing
1687    *           all of the relationship assertions currently attributed to the publisher account
1688    *           that is associated with the authInfo data passed.
1689    * @exception UDDIException
1690    * @exception TransportException
1691    */
1692   public  PublisherAssertions set_publisherAssertions (String    authInfo,
1693                                                        Vector   publisherAssertion)
1694           throws UDDIException, TransportException {
1695       SetPublisherAssertions request = new SetPublisherAssertions();
1696       request.setAuthInfo(authInfo);
1697       request.setPublisherAssertionVector(publisherAssertion);
1698       return new PublisherAssertions(send(request, false));
1699   }
1700
1701   /**
1702    * A UDDI operator sends the validate_values message to the appropriate external service, whenever a
1703    * publisher saves data that uses a categorization value or identifier whose use is regulated by the
1704    * external party who controls that service. The normal use is to verify that specific categories or
1705    * identifiers (checking the keyValue attribute values supplied) exist within the given taxonomy or
1706    * identifier system
1707    *
1708    * @param businessEntity
1709    *                  The vector of businessEntity structure being validated.
1710    * @return Upon successful completion, a dispositionReport is returned with a
1711    *         single success indicator.
1712    * @exception UDDIException
1713    * @exception TransportException
1714    */
1715   public DispositionReport validate_values_businessEntity(Vector   businessEntity)
1716          throws UDDIException, TransportException {
1717       ValidateValues request = new ValidateValues();
1718       request.setBusinessEntityVector(businessEntity);
1719       return new DispositionReport(send(request, true));
1720   }
1721
1722   /**
1723    * A UDDI operator sends the validate_values message to the appropriate external service, whenever a
1724    * publisher saves data that uses a categorization value or identifier whose use is regulated by the
1725    * external party who controls that service. The normal use is to verify that specific categories or
1726    * identifiers (checking the keyValue attribute values supplied) exist within the given taxonomy or
1727    * identifier system
1728    *
1729    * @param businessService
1730    *                  The vector of business service structure being validated.
1731    * @return Upon successful completion, a dispositionReport is returned with a
1732    *         single success indicator.
1733    * @exception UDDIException
1734    * @exception TransportException
1735    */
1736   public DispositionReport validate_values_businessService(Vector   businessService)
1737             throws UDDIException, TransportException {
1738          ValidateValues request = new ValidateValues();
1739          request.setBusinessServiceVector(businessService);
1740          return new DispositionReport(send(request, true));
1741   }
1742
1743   /**
1744    * A UDDI operator sends the validate_values message to the appropriate external service, whenever a
1745    * publisher saves data that uses a categorization value or identifier whose use is regulated by the
1746    * external party who controls that service. The normal use is to verify that specific categories or
1747    * identifiers (checking the keyValue attribute values supplied) exist within the given taxonomy or
1748    * identifier system
1749    *
1750    * @param tModel    The vector of tModel structure being validated.
1751    * @return Upon successful completion, a dispositionReport is returned with a
1752    *         single success indicator.
1753    * @exception UDDIException
1754    * @exception TransportException
1755    */
1756
1757   public DispositionReport validate_values_tModel(Vector   tModel)
1758             throws UDDIException, TransportException {
1759          ValidateValues request = new ValidateValues();
1760          request.setTModelVector(tModel);
1761          return new DispositionReport(send(request, true));
1762   }
1763
1764
1765   /**
1766    * Sends a UDDIElement to either the inquiry or publish URL.
1767    *
1768    * @param el
1769    * @param inquiry
1770    * @return An element representing a XML DOM tree containing the UDDI response.
1771    * @exception TransportException
1772    */
1773   public Element send(UDDIElement el, boolean inquiry) throws TransportException {
1774
1775      Element result = null;
1776
1777      if (inquiry) {
1778         result = transportFactory.getTransport().send(el, inquiryURL);
1779      } else {
1780         result = transportFactory.getTransport().send(el, publishURL);
1781      }
1782      return result;
1783   }
1784
1785   /**
1786    * Sends an XML DOM tree indentified by the given element to either the
1787    * inquiry or publish URL. Can be used to send an manually constructed
1788    * message to the UDDI registry.
1789    *
1790    * @param el
1791    * @param inquiry
1792    * @return An element representing a XML DOM tree containing the UDDI response.
1793    * @exception TransportException
1794    */
1795   public Element send(Element el, boolean inquiry) throws TransportException {
1796
1797      Element result = null;
1798
1799      if (inquiry) {
1800         result = transportFactory.getTransport().send(el, inquiryURL);
1801      } else {
1802         result = transportFactory.getTransport().send(el, publishURL);
1803      }
1804      return result;
1805   }
1806
1807}
1808
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags