← Back to branch summary

~ubuntu-branches/debian/squeeze/axis/squeeze

« back to all changes in this revision

Viewing changes to src/org/apache/axis/wsdl/Java2WSDL.java

  • Committer: Bazaar Package Importer
  • Author(s): Vladimír Lapáček
  • Date: 2006-09-06 22:31:39 UTC
  • Revision ID: james.westby@ubuntu.com-20060906223139-l7m5edxeositeppl
Tags: upstream-1.4
Import upstream version 1.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/apache/axis/wsdl/Java2WSDL.java
 
1
/*
 
2
 * Copyright 2001-2004 The Apache Software Foundation.
 
3
 * 
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 * 
 
8
 *      http://www.apache.org/licenses/LICENSE-2.0
 
9
 * 
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
package org.apache.axis.wsdl;
 
17
 
 
18
import org.apache.axis.utils.CLArgsParser;
 
19
import org.apache.axis.utils.CLOption;
 
20
import org.apache.axis.utils.CLOptionDescriptor;
 
21
import org.apache.axis.utils.CLUtil;
 
22
import org.apache.axis.utils.ClassUtils;
 
23
import org.apache.axis.utils.Messages;
 
24
import org.apache.axis.wsdl.fromJava.Emitter;
 
25
import org.apache.axis.encoding.TypeMappingRegistryImpl;
 
26
import org.apache.axis.encoding.TypeMappingImpl;
 
27
 
 
28
import java.io.File;
 
29
import java.util.HashMap;
 
30
import java.util.Iterator;
 
31
import java.util.List;
 
32
import java.util.Map;
 
33
 
 
34
/**
 
35
 * Command line interface to the java2wsdl utility
 
36
 * 
 
37
 * @author Ravi Kumar (rkumar@borland.com)
 
38
 * @author Rich Scheuerle (scheu@us.ibm.com)
 
39
 */
 
40
public class Java2WSDL {
 
41
 
 
42
    // Define our short one-letter option identifiers.
 
43
 
 
44
    /** Field INHERITED_CLASS_OPT */
 
45
    protected static final int INHERITED_CLASS_OPT = 'a';
 
46
 
 
47
    /** Field SOAPACTION_OPT */
 
48
    protected static final int SOAPACTION_OPT = 'A';
 
49
 
 
50
    /** Field BINDING_NAME_OPT */
 
51
    protected static final int BINDING_NAME_OPT = 'b';
 
52
 
 
53
    /** Field STOP_CLASSES_OPT */
 
54
    protected static final int STOP_CLASSES_OPT = 'c';
 
55
 
 
56
    /** Field IMPORT_SCHEMA_OPT */
 
57
    protected static final int IMPORT_SCHEMA_OPT = 'C';
 
58
 
 
59
    /** Field EXTRA_CLASSES_OPT */
 
60
    protected static final int EXTRA_CLASSES_OPT = 'e';
 
61
 
 
62
    /** Field HELP_OPT */
 
63
    protected static final int HELP_OPT = 'h';
 
64
 
 
65
    /** Field IMPL_CLASS_OPT */
 
66
    protected static final int IMPL_CLASS_OPT = 'i';
 
67
 
 
68
    /** Field INPUT_OPT */
 
69
    protected static final int INPUT_OPT = 'I';
 
70
 
 
71
    /** Field LOCATION_OPT */
 
72
    protected static final int LOCATION_OPT = 'l';
 
73
 
 
74
    /** Field LOCATION_IMPORT_OPT */
 
75
    protected static final int LOCATION_IMPORT_OPT = 'L';
 
76
 
 
77
    /** Field METHODS_ALLOWED_OPT */
 
78
    protected static final int METHODS_ALLOWED_OPT = 'm';
 
79
 
 
80
    /** Field NAMESPACE_OPT */
 
81
    protected static final int NAMESPACE_OPT = 'n';
 
82
 
 
83
    /** Field NAMESPACE_IMPL_OPT */
 
84
    protected static final int NAMESPACE_IMPL_OPT = 'N';
 
85
 
 
86
    /** Field OUTPUT_OPT */
 
87
    protected static final int OUTPUT_OPT = 'o';
 
88
 
 
89
    /** Field OUTPUT_IMPL_OPT */
 
90
    protected static final int OUTPUT_IMPL_OPT = 'O';
 
91
 
 
92
    /** Field PACKAGE_OPT */
 
93
    protected static final int PACKAGE_OPT = 'p';
 
94
 
 
95
    /** Field PORTTYPE_NAME_OPT */
 
96
    protected static final int PORTTYPE_NAME_OPT = 'P';
 
97
 
 
98
    /** Field SERVICE_PORT_NAME_OPT */
 
99
    protected static final int SERVICE_PORT_NAME_OPT = 's';
 
100
 
 
101
    /** Field SERVICE_ELEMENT_NAME_OPT */
 
102
    protected static final int SERVICE_ELEMENT_NAME_OPT = 'S';
 
103
 
 
104
    /** Field TYPEMAPPING_OPT */
 
105
    protected static final int TYPEMAPPING_OPT = 'T';
 
106
 
 
107
    /** Field USE_OPT */
 
108
    protected static final int USE_OPT = 'u';
 
109
 
 
110
    /** Field OUTPUT_WSDL_MODE_OPT */
 
111
    protected static final int OUTPUT_WSDL_MODE_OPT = 'w';
 
112
 
 
113
    /** Field METHODS_NOTALLOWED_OPT */
 
114
    protected static final int METHODS_NOTALLOWED_OPT = 'x';
 
115
 
 
116
    protected static final int CLASSPATH_OPT = 'X';
 
117
 
 
118
    /** Field STYLE_OPT */
 
119
    protected static final int STYLE_OPT = 'y';
 
120
        
 
121
    /** Field DEPLOY_OPT */
 
122
    protected static final int DEPLOY_OPT = 'd';
 
123
 
 
124
    /**
 
125
     * Define the understood options. Each CLOptionDescriptor contains:
 
126
     * - The "long" version of the option. Eg, "help" means that "--help" will
 
127
     * be recognised.
 
128
     * - The option flags, governing the option's argument(s).
 
129
     * - The "short" version of the option. Eg, 'h' means that "-h" will be
 
130
     * recognised.
 
131
     * - A description of the option for the usage message
 
132
     */
 
133
    protected CLOptionDescriptor[] options = new CLOptionDescriptor[]{
 
134
        new CLOptionDescriptor("help", CLOptionDescriptor.ARGUMENT_DISALLOWED,
 
135
                HELP_OPT, Messages.getMessage("j2wopthelp00")),
 
136
        new CLOptionDescriptor("input", CLOptionDescriptor.ARGUMENT_REQUIRED,
 
137
                INPUT_OPT, Messages.getMessage("j2woptinput00")),
 
138
        new CLOptionDescriptor("output", CLOptionDescriptor.ARGUMENT_REQUIRED,
 
139
                OUTPUT_OPT,
 
140
                Messages.getMessage("j2woptoutput00")),
 
141
        new CLOptionDescriptor("location",
 
142
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
143
                LOCATION_OPT,
 
144
                Messages.getMessage("j2woptlocation00")),
 
145
        new CLOptionDescriptor("portTypeName",
 
146
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
147
                PORTTYPE_NAME_OPT,
 
148
                Messages.getMessage("j2woptportTypeName00")),
 
149
        new CLOptionDescriptor("bindingName",
 
150
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
151
                BINDING_NAME_OPT,
 
152
                Messages.getMessage("j2woptbindingName00")),
 
153
        new CLOptionDescriptor(
 
154
                "serviceElementName", CLOptionDescriptor.ARGUMENT_REQUIRED,
 
155
                SERVICE_ELEMENT_NAME_OPT,
 
156
                Messages.getMessage("j2woptserviceElementName00")),
 
157
        new CLOptionDescriptor("servicePortName",
 
158
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
159
                SERVICE_PORT_NAME_OPT,
 
160
                Messages.getMessage("j2woptservicePortName00")),
 
161
        new CLOptionDescriptor("namespace",
 
162
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
163
                NAMESPACE_OPT,
 
164
                Messages.getMessage("j2woptnamespace00")),
 
165
        new CLOptionDescriptor("PkgtoNS",
 
166
                CLOptionDescriptor.DUPLICATES_ALLOWED
 
167
            + CLOptionDescriptor.ARGUMENTS_REQUIRED_2,
 
168
                PACKAGE_OPT,
 
169
                Messages.getMessage("j2woptPkgtoNS00")),
 
170
        new CLOptionDescriptor("methods",
 
171
                CLOptionDescriptor.DUPLICATES_ALLOWED
 
172
            + CLOptionDescriptor.ARGUMENT_REQUIRED,
 
173
                METHODS_ALLOWED_OPT,
 
174
                Messages.getMessage("j2woptmethods00")),
 
175
        new CLOptionDescriptor("all", CLOptionDescriptor.ARGUMENT_DISALLOWED,
 
176
                INHERITED_CLASS_OPT,
 
177
                Messages.getMessage("j2woptall00")),
 
178
        new CLOptionDescriptor("outputWsdlMode",
 
179
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
180
                OUTPUT_WSDL_MODE_OPT,
 
181
                Messages.getMessage("j2woptoutputWsdlMode00")),
 
182
        new CLOptionDescriptor("locationImport",
 
183
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
184
                LOCATION_IMPORT_OPT,
 
185
                Messages.getMessage("j2woptlocationImport00")),
 
186
        new CLOptionDescriptor("namespaceImpl",
 
187
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
188
                NAMESPACE_IMPL_OPT,
 
189
                Messages.getMessage("j2woptnamespaceImpl00")),
 
190
        new CLOptionDescriptor("outputImpl",
 
191
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
192
                OUTPUT_IMPL_OPT,
 
193
                Messages.getMessage("j2woptoutputImpl00")),
 
194
        new CLOptionDescriptor("implClass",
 
195
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
196
                IMPL_CLASS_OPT,
 
197
                Messages.getMessage("j2woptimplClass00")),
 
198
        new CLOptionDescriptor("exclude",
 
199
                CLOptionDescriptor.DUPLICATES_ALLOWED
 
200
            + CLOptionDescriptor.ARGUMENT_REQUIRED,
 
201
                METHODS_NOTALLOWED_OPT,
 
202
                Messages.getMessage("j2woptexclude00")),
 
203
        new CLOptionDescriptor("stopClasses",
 
204
                CLOptionDescriptor.DUPLICATES_ALLOWED
 
205
            + CLOptionDescriptor.ARGUMENT_REQUIRED,
 
206
                STOP_CLASSES_OPT,
 
207
                Messages.getMessage("j2woptstopClass00")),
 
208
        new CLOptionDescriptor("typeMappingVersion",
 
209
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
210
                TYPEMAPPING_OPT,
 
211
                Messages.getMessage("j2wopttypeMapping00")),
 
212
        new CLOptionDescriptor("soapAction",
 
213
                CLOptionDescriptor.ARGUMENT_REQUIRED,
 
214
                SOAPACTION_OPT,
 
215
                Messages.getMessage("j2woptsoapAction00")),
 
216
        new CLOptionDescriptor("style", CLOptionDescriptor.ARGUMENT_REQUIRED,
 
217
                STYLE_OPT, Messages.getMessage("j2woptStyle00")),
 
218
        new CLOptionDescriptor("use", CLOptionDescriptor.ARGUMENT_REQUIRED,
 
219
                USE_OPT, Messages.getMessage("j2woptUse00")),
 
220
        new CLOptionDescriptor("extraClasses",
 
221
                CLOptionDescriptor.DUPLICATES_ALLOWED
 
222
            + CLOptionDescriptor.ARGUMENT_REQUIRED,
 
223
                EXTRA_CLASSES_OPT,
 
224
                Messages.getMessage("j2woptExtraClasses00")),
 
225
        new CLOptionDescriptor("importSchema",
 
226
                CLOptionDescriptor.ARGUMENT_OPTIONAL,
 
227
                IMPORT_SCHEMA_OPT,
 
228
                Messages.getMessage("j2woptImportSchema00")),
 
229
        new CLOptionDescriptor("classpath",
 
230
                CLOptionDescriptor.ARGUMENT_OPTIONAL,
 
231
                CLASSPATH_OPT,
 
232
                Messages.getMessage("optionClasspath")),
 
233
        new CLOptionDescriptor("deploy",
 
234
                        CLOptionDescriptor.ARGUMENT_DISALLOWED,
 
235
                        DEPLOY_OPT,
 
236
                        Messages.getMessage("j2woptDeploy00")),
 
237
    };
 
238
 
 
239
    /** Field emitter */
 
240
    protected Emitter emitter;
 
241
 
 
242
    /** Field className */
 
243
    protected String className = null;
 
244
 
 
245
    /** Field wsdlFilename */
 
246
    protected String wsdlFilename = null;
 
247
 
 
248
    /** Field wsdlImplFilename */
 
249
    protected String wsdlImplFilename = null;
 
250
 
 
251
    /** Field namespaceMap */
 
252
    protected HashMap namespaceMap = new HashMap();
 
253
 
 
254
    /** Field mode */
 
255
    protected int mode = Emitter.MODE_ALL;
 
256
 
 
257
    /** Field locationSet */
 
258
    boolean locationSet = false;
 
259
 
 
260
    /** Field typeMappingVersion */
 
261
    protected String typeMappingVersion = "1.2";
 
262
    
 
263
    /** Field isDeplpy */
 
264
    protected boolean isDeploy = false;
 
265
    
 
266
    /**
 
267
     * Instantiate a Java2WSDL emitter.
 
268
     */
 
269
    protected Java2WSDL() {
 
270
        emitter = createEmitter();
 
271
    }    // ctor
 
272
 
 
273
    /**
 
274
     * Instantiate an Emitter
 
275
     * 
 
276
     * @return 
 
277
     */
 
278
    protected Emitter createEmitter() {
 
279
        return new Emitter();
 
280
    }    // createEmitter
 
281
 
 
282
    /**
 
283
     * addOptions
 
284
     * Add option descriptions to the tool.  Allows
 
285
     * extended classes to add additional options.
 
286
     * 
 
287
     * @param newOptions CLOptionDescriptor[] the options
 
288
     */
 
289
    protected void addOptions(CLOptionDescriptor[] newOptions) {
 
290
 
 
291
        if ((newOptions != null) && (newOptions.length > 0)) {
 
292
            CLOptionDescriptor[] allOptions =
 
293
                    new CLOptionDescriptor[options.length + newOptions.length];
 
294
 
 
295
            System.arraycopy(options, 0, allOptions, 0, options.length);
 
296
            System.arraycopy(newOptions, 0, allOptions, options.length,
 
297
                    newOptions.length);
 
298
 
 
299
            options = allOptions;
 
300
        }
 
301
    }
 
302
 
 
303
    /**
 
304
     * Parse an option
 
305
     * 
 
306
     * @param option CLOption is the option
 
307
     * @return 
 
308
     */
 
309
    protected boolean parseOption(CLOption option) {
 
310
 
 
311
        String value;
 
312
        boolean status = true;
 
313
 
 
314
        switch (option.getId()) {
 
315
 
 
316
            case CLOption.TEXT_ARGUMENT:
 
317
                if (className != null) {
 
318
                    System.out.println(
 
319
                            Messages.getMessage(
 
320
                                    "j2wDuplicateClass00", className,
 
321
                                    option.getArgument()));
 
322
                    printUsage();
 
323
 
 
324
                    status = false;    // error
 
325
                }
 
326
 
 
327
                className = option.getArgument();
 
328
                break;
 
329
 
 
330
            case METHODS_ALLOWED_OPT:
 
331
                emitter.setAllowedMethods(option.getArgument());
 
332
                break;
 
333
 
 
334
            case INHERITED_CLASS_OPT:
 
335
                emitter.setUseInheritedMethods(true);
 
336
                break;
 
337
 
 
338
            case IMPL_CLASS_OPT:
 
339
                emitter.setImplCls(option.getArgument());
 
340
                break;
 
341
 
 
342
            case HELP_OPT:
 
343
                printUsage();
 
344
 
 
345
                status = false;
 
346
                break;
 
347
 
 
348
            case OUTPUT_WSDL_MODE_OPT:
 
349
                String modeArg = option.getArgument();
 
350
 
 
351
                if ("All".equalsIgnoreCase(modeArg)) {
 
352
                    mode = Emitter.MODE_ALL;
 
353
                } else if ("Interface".equalsIgnoreCase(modeArg)) {
 
354
                    mode = Emitter.MODE_INTERFACE;
 
355
                } else if ("Implementation".equalsIgnoreCase(modeArg)) {
 
356
                    mode = Emitter.MODE_IMPLEMENTATION;
 
357
                } else {
 
358
                    mode = Emitter.MODE_ALL;
 
359
 
 
360
                    System.err.println(Messages.getMessage("j2wmodeerror",
 
361
                            modeArg));
 
362
                }
 
363
                break;
 
364
 
 
365
            case OUTPUT_OPT:
 
366
                wsdlFilename = option.getArgument();
 
367
                break;
 
368
 
 
369
            case INPUT_OPT:
 
370
                emitter.setInputWSDL(option.getArgument());
 
371
                break;
 
372
 
 
373
            case OUTPUT_IMPL_OPT:
 
374
                wsdlImplFilename = option.getArgument();
 
375
                break;
 
376
 
 
377
            case PACKAGE_OPT:
 
378
                String packageName = option.getArgument(0);
 
379
                String namespace = option.getArgument(1);
 
380
 
 
381
                namespaceMap.put(packageName, namespace);
 
382
                break;
 
383
 
 
384
            case NAMESPACE_OPT:
 
385
                emitter.setIntfNamespace(option.getArgument());
 
386
                break;
 
387
 
 
388
            case NAMESPACE_IMPL_OPT:
 
389
                emitter.setImplNamespace(option.getArgument());
 
390
                break;
 
391
 
 
392
            case SERVICE_ELEMENT_NAME_OPT:
 
393
                emitter.setServiceElementName(option.getArgument());
 
394
                break;
 
395
 
 
396
            case SERVICE_PORT_NAME_OPT:
 
397
                emitter.setServicePortName(option.getArgument());
 
398
                break;
 
399
 
 
400
            case LOCATION_OPT:
 
401
                emitter.setLocationUrl(option.getArgument());
 
402
 
 
403
                locationSet = true;
 
404
                break;
 
405
 
 
406
            case LOCATION_IMPORT_OPT:
 
407
                emitter.setImportUrl(option.getArgument());
 
408
                break;
 
409
 
 
410
            case METHODS_NOTALLOWED_OPT:
 
411
                emitter.setDisallowedMethods(option.getArgument());
 
412
                break;
 
413
 
 
414
            case PORTTYPE_NAME_OPT:
 
415
                emitter.setPortTypeName(option.getArgument());
 
416
                break;
 
417
 
 
418
            case BINDING_NAME_OPT:
 
419
                emitter.setBindingName(option.getArgument());
 
420
                break;
 
421
 
 
422
            case STOP_CLASSES_OPT:
 
423
                emitter.setStopClasses(option.getArgument());
 
424
                break;
 
425
 
 
426
            case TYPEMAPPING_OPT:
 
427
                value = option.getArgument();
 
428
                typeMappingVersion = value;
 
429
                break;
 
430
 
 
431
            case SOAPACTION_OPT:
 
432
                value = option.getArgument();
 
433
 
 
434
                if (value.equalsIgnoreCase("DEFAULT")) {
 
435
                    emitter.setSoapAction("DEFAULT");
 
436
                } else if (value.equalsIgnoreCase("OPERATION")) {
 
437
                    emitter.setSoapAction("OPERATION");
 
438
                } else if (value.equalsIgnoreCase("NONE")) {
 
439
                    emitter.setSoapAction("NONE");
 
440
                } else {
 
441
                    System.out.println(
 
442
                            Messages.getMessage("j2wBadSoapAction00"));
 
443
 
 
444
                    status = false;
 
445
                }
 
446
                break;
 
447
 
 
448
            case STYLE_OPT:
 
449
                value = option.getArgument();
 
450
 
 
451
                if (value.equalsIgnoreCase("DOCUMENT")
 
452
                        || value.equalsIgnoreCase("RPC")
 
453
                        || value.equalsIgnoreCase("WRAPPED")) {
 
454
                    emitter.setStyle(value);
 
455
                } else {
 
456
                    System.out.println(Messages.getMessage("j2woptBadStyle00"));
 
457
 
 
458
                    status = false;
 
459
                }
 
460
                break;
 
461
 
 
462
            case USE_OPT:
 
463
                value = option.getArgument();
 
464
 
 
465
                if (value.equalsIgnoreCase("LITERAL")
 
466
                        || value.equalsIgnoreCase("ENCODED")) {
 
467
                    emitter.setUse(value);
 
468
                } else {
 
469
                    System.out.println(Messages.getMessage("j2woptBadUse00"));
 
470
 
 
471
                    status = false;
 
472
                }
 
473
                break;
 
474
 
 
475
            case EXTRA_CLASSES_OPT:
 
476
                try {
 
477
                    emitter.setExtraClasses(option.getArgument());
 
478
                } catch (ClassNotFoundException e) {
 
479
                    System.out.println(Messages.getMessage("j2woptBadClass00",
 
480
                            e.toString()));
 
481
 
 
482
                    status = false;
 
483
                }
 
484
                break;
 
485
 
 
486
            case IMPORT_SCHEMA_OPT:
 
487
                emitter.setInputSchema(option.getArgument());
 
488
                break;
 
489
 
 
490
            case CLASSPATH_OPT:
 
491
                ClassUtils.setDefaultClassLoader(ClassUtils.createClassLoader(
 
492
                        option.getArgument(),
 
493
                        this.getClass().getClassLoader()));
 
494
                break;
 
495
                
 
496
            case DEPLOY_OPT:
 
497
                isDeploy = true;
 
498
                break;
 
499
                
 
500
            default :
 
501
                break;
 
502
        }
 
503
 
 
504
        return status;
 
505
    }
 
506
 
 
507
    /**
 
508
     * validateOptions
 
509
     * This method is invoked after the options are set to validate
 
510
     * the option settings.
 
511
     * 
 
512
     * @return 
 
513
     */
 
514
    protected boolean validateOptions() {
 
515
 
 
516
        // Can't proceed without a class name
 
517
        if ((className == null)) {
 
518
            System.out.println(Messages.getMessage("j2wMissingClass00"));
 
519
            printUsage();
 
520
 
 
521
            return false;
 
522
        }
 
523
 
 
524
        if (!locationSet
 
525
                && ((mode == Emitter.MODE_ALL)
 
526
                || (mode == Emitter.MODE_IMPLEMENTATION))) {
 
527
            System.out.println(Messages.getMessage("j2wMissingLocation00"));
 
528
            printUsage();
 
529
 
 
530
            return false;
 
531
        }
 
532
        return true;    // a-OK
 
533
    }
 
534
 
 
535
    /**
 
536
     * run
 
537
     * checks the command-line arguments and runs the tool.
 
538
     * 
 
539
     * @param args String[] command-line arguments.
 
540
     * @return 
 
541
     */
 
542
    protected int run(String[] args) {
 
543
 
 
544
        // Parse the arguments
 
545
        CLArgsParser argsParser = new CLArgsParser(args, options);
 
546
 
 
547
        // Print parser errors, if any
 
548
        if (null != argsParser.getErrorString()) {
 
549
            System.err.println(
 
550
                    Messages.getMessage("j2werror00", argsParser.getErrorString()));
 
551
            printUsage();
 
552
 
 
553
            return (1);
 
554
        }
 
555
 
 
556
        // Get a list of parsed options
 
557
        List clOptions = argsParser.getArguments();
 
558
        int size = clOptions.size();
 
559
 
 
560
        try {
 
561
 
 
562
            // Parse the options and configure the emitter as appropriate.
 
563
            for (int i = 0; i < size; i++) {
 
564
                if (parseOption((CLOption) clOptions.get(i)) == false) {
 
565
                    return (1);
 
566
                }
 
567
            }
 
568
 
 
569
            // validate argument combinations
 
570
            if (validateOptions() == false) {
 
571
                return (1);
 
572
            }
 
573
 
 
574
            // Set the namespace map
 
575
            if (!namespaceMap.isEmpty()) {
 
576
                emitter.setNamespaceMap(namespaceMap);
 
577
            }
 
578
 
 
579
            TypeMappingRegistryImpl tmr = new TypeMappingRegistryImpl();
 
580
            tmr.doRegisterFromVersion(typeMappingVersion);
 
581
            emitter.setTypeMappingRegistry(tmr);
 
582
 
 
583
            // Find the class using the name
 
584
            emitter.setCls(className);
 
585
 
 
586
            // Generate a full wsdl, or interface & implementation wsdls
 
587
            if (wsdlImplFilename == null) {
 
588
                emitter.emit(wsdlFilename, mode);
 
589
            } else {
 
590
                emitter.emit(wsdlFilename, wsdlImplFilename);
 
591
            }
 
592
                                                                        
 
593
            if (isDeploy) {
 
594
                generateServerSide(emitter, (wsdlImplFilename != null) ? wsdlImplFilename : wsdlFilename);             
 
595
            }
 
596
            // everything is good
 
597
            return (0);
 
598
        } catch (Throwable t) {
 
599
            t.printStackTrace();
 
600
 
 
601
            return (1);
 
602
        }
 
603
    }    // run
 
604
 
 
605
    /**
 
606
     * Generate the server side artifacts from the generated WSDL
 
607
     * 
 
608
     * @param j2w the Java2WSDL emitter
 
609
     * @param wsdlFileName the generated WSDL file
 
610
     * @throws Exception
 
611
     */
 
612
    protected void generateServerSide(Emitter j2w, String wsdlFileName) throws Exception {
 
613
        org.apache.axis.wsdl.toJava.Emitter w2j = new org.apache.axis.wsdl.toJava.Emitter();
 
614
        File wsdlFile = new File(wsdlFileName);
 
615
        w2j.setServiceDesc(j2w.getServiceDesc());
 
616
        w2j.setQName2ClassMap(j2w.getQName2ClassMap());
 
617
        w2j.setOutputDir(wsdlFile.getParent());
 
618
        w2j.setServerSide(true);        
 
619
        w2j.setHelperWanted(true);
 
620
        
 
621
        // setup namespace-to-package mapping
 
622
        String ns = j2w.getIntfNamespace();
 
623
        String pkg = j2w.getCls().getPackage().getName();
 
624
        w2j.getNamespaceMap().put(ns, pkg);
 
625
        
 
626
        Map nsmap = j2w.getNamespaceMap();
 
627
        if (nsmap != null) {
 
628
            for (Iterator i = nsmap.keySet().iterator(); i.hasNext(); ) {
 
629
                pkg = (String) i.next();
 
630
                ns = (String) nsmap.get(pkg);
 
631
                w2j.getNamespaceMap().put(ns, pkg);
 
632
            }
 
633
        }
 
634
        
 
635
        // set 'deploy' mode
 
636
        w2j.setDeploy(true);
 
637
        
 
638
        if (j2w.getImplCls() != null) {
 
639
            w2j.setImplementationClassName(j2w.getImplCls().getName());
 
640
        } else {
 
641
            if (!j2w.getCls().isInterface()) {
 
642
                w2j.setImplementationClassName(j2w.getCls().getName());
 
643
            } else {
 
644
                throw new Exception("implementation class is not specified.");
 
645
            }
 
646
        }
 
647
        
 
648
        w2j.run(wsdlFileName);
 
649
    }
 
650
    /**
 
651
     * printUsage
 
652
     * print usage information and quit.
 
653
     */
 
654
    protected void printUsage() {
 
655
 
 
656
        String lSep = System.getProperty("line.separator");
 
657
        StringBuffer msg = new StringBuffer();
 
658
 
 
659
        msg.append("Java2WSDL "
 
660
                + Messages.getMessage("j2wemitter00")).append(lSep);
 
661
        msg.append(
 
662
                Messages.getMessage(
 
663
                        "j2wusage00",
 
664
                        "java " + getClass().getName()
 
665
                + " [options] class-of-portType")).append(lSep);
 
666
        msg.append(Messages.getMessage("j2woptions00")).append(lSep);
 
667
        msg.append(CLUtil.describeOptions(options).toString());
 
668
        msg.append(Messages.getMessage("j2wdetails00")).append(lSep);
 
669
        System.out.println(msg.toString());
 
670
    }
 
671
 
 
672
    /**
 
673
     * Main
 
674
     * Run the Java2WSDL emitter with the specified command-line arguments
 
675
     * 
 
676
     * @param args String[] command-line arguments
 
677
     */
 
678
    public static void main(String args[]) {
 
679
 
 
680
        Java2WSDL java2wsdl = new Java2WSDL();
 
681
 
 
682
        System.exit(java2wsdl.run(args));
 
683
    }
 
684
}