0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s):
0025: *
0026: * The Original Software is NetBeans. The Initial Developer of the Original
0027: * Software is Sun Microsystems, Inc. Portions Copyright 2006 Sun
0028: * Microsystems, Inc. All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: */
0041:
0042: package org.netbeans.modules.websvc.wsitmodelext.security.tokens;
0043:
0044: import org.netbeans.modules.websvc.wsitmodelext.security.tokens.impl.*;
0045: import org.netbeans.modules.xml.wsdl.model.WSDLComponent;
0046: import org.netbeans.modules.xml.wsdl.model.spi.ElementFactory;
0047: import org.w3c.dom.Element;
0048:
0049: import javax.xml.namespace.QName;
0050: import java.util.Collections;
0051: import java.util.Set;
0052:
0053: public class TokenFactories {
0054:
0055: public static class SupportingTokensFactory extends ElementFactory {
0056: @Override
0057: public Set<QName> getElementQNames() {
0058: return Collections.singleton(TokensQName.SUPPORTINGTOKENS
0059: .getQName());
0060: }
0061:
0062: public <C extends WSDLComponent> C create(
0063: WSDLComponent context, Class<C> type) {
0064: return type.cast(new SupportingTokensImpl(context
0065: .getModel()));
0066: }
0067:
0068: @Override
0069: public WSDLComponent create(WSDLComponent context,
0070: Element element) {
0071: return new SupportingTokensImpl(context.getModel(), element);
0072: }
0073: }
0074:
0075: public static class SignedSupportingTokensFactory extends
0076: ElementFactory {
0077: @Override
0078: public Set<QName> getElementQNames() {
0079: return Collections
0080: .singleton(TokensQName.SIGNEDSUPPORTINGTOKENS
0081: .getQName());
0082: }
0083:
0084: public <C extends WSDLComponent> C create(
0085: WSDLComponent context, Class<C> type) {
0086: return type.cast(new SignedSupportingTokensImpl(context
0087: .getModel()));
0088: }
0089:
0090: @Override
0091: public WSDLComponent create(WSDLComponent context,
0092: Element element) {
0093: return new SignedSupportingTokensImpl(context.getModel(),
0094: element);
0095: }
0096: }
0097:
0098: public static class EndorsingSupportingTokensFactory extends
0099: ElementFactory {
0100: @Override
0101: public Set<QName> getElementQNames() {
0102: return Collections
0103: .singleton(TokensQName.ENDORSINGSUPPORTINGTOKENS
0104: .getQName());
0105: }
0106:
0107: public <C extends WSDLComponent> C create(
0108: WSDLComponent context, Class<C> type) {
0109: return type.cast(new EndorsingSupportingTokensImpl(context
0110: .getModel()));
0111: }
0112:
0113: @Override
0114: public WSDLComponent create(WSDLComponent context,
0115: Element element) {
0116: return new EndorsingSupportingTokensImpl(
0117: context.getModel(), element);
0118: }
0119: }
0120:
0121: public static class SignedEndorsingSupportingTokensFactory extends
0122: ElementFactory {
0123: @Override
0124: public Set<QName> getElementQNames() {
0125: return Collections
0126: .singleton(TokensQName.SIGNEDENDORSINGSUPPORTINGTOKENS
0127: .getQName());
0128: }
0129:
0130: public <C extends WSDLComponent> C create(
0131: WSDLComponent context, Class<C> type) {
0132: return type.cast(new SignedEndorsingSupportingTokensImpl(
0133: context.getModel()));
0134: }
0135:
0136: @Override
0137: public WSDLComponent create(WSDLComponent context,
0138: Element element) {
0139: return new SignedEndorsingSupportingTokensImpl(context
0140: .getModel(), element);
0141: }
0142: }
0143:
0144: public static class HttpsTokenFactory extends ElementFactory {
0145: @Override
0146: public Set<QName> getElementQNames() {
0147: return Collections.singleton(TokensQName.HTTPSTOKEN
0148: .getQName());
0149: }
0150:
0151: public <C extends WSDLComponent> C create(
0152: WSDLComponent context, Class<C> type) {
0153: return type.cast(new HttpsTokenImpl(context.getModel()));
0154: }
0155:
0156: @Override
0157: public WSDLComponent create(WSDLComponent context,
0158: Element element) {
0159: return new HttpsTokenImpl(context.getModel(), element);
0160: }
0161: }
0162:
0163: public static class InitiatorTokenFactory extends ElementFactory {
0164: @Override
0165: public Set<QName> getElementQNames() {
0166: return Collections.singleton(TokensQName.INITIATORTOKEN
0167: .getQName());
0168: }
0169:
0170: public <C extends WSDLComponent> C create(
0171: WSDLComponent context, Class<C> type) {
0172: return type
0173: .cast(new InitiatorTokenImpl(context.getModel()));
0174: }
0175:
0176: @Override
0177: public WSDLComponent create(WSDLComponent context,
0178: Element element) {
0179: return new InitiatorTokenImpl(context.getModel(), element);
0180: }
0181: }
0182:
0183: public static class SignatureTokenFactory extends ElementFactory {
0184: @Override
0185: public Set<QName> getElementQNames() {
0186: return Collections.singleton(TokensQName.SIGNATURETOKEN
0187: .getQName());
0188: }
0189:
0190: public <C extends WSDLComponent> C create(
0191: WSDLComponent context, Class<C> type) {
0192: return type
0193: .cast(new SignatureTokenImpl(context.getModel()));
0194: }
0195:
0196: @Override
0197: public WSDLComponent create(WSDLComponent context,
0198: Element element) {
0199: return new SignatureTokenImpl(context.getModel(), element);
0200: }
0201: }
0202:
0203: public static class EncryptionTokenFactory extends ElementFactory {
0204: @Override
0205: public Set<QName> getElementQNames() {
0206: return Collections.singleton(TokensQName.ENCRYPTIONTOKEN
0207: .getQName());
0208: }
0209:
0210: public <C extends WSDLComponent> C create(
0211: WSDLComponent context, Class<C> type) {
0212: return type
0213: .cast(new EncryptionTokenImpl(context.getModel()));
0214: }
0215:
0216: @Override
0217: public WSDLComponent create(WSDLComponent context,
0218: Element element) {
0219: return new EncryptionTokenImpl(context.getModel(), element);
0220: }
0221: }
0222:
0223: public static class IssuedTokenFactory extends ElementFactory {
0224: @Override
0225: public Set<QName> getElementQNames() {
0226: return Collections.singleton(TokensQName.ISSUEDTOKEN
0227: .getQName());
0228: }
0229:
0230: public <C extends WSDLComponent> C create(
0231: WSDLComponent context, Class<C> type) {
0232: return type.cast(new IssuedTokenImpl(context.getModel()));
0233: }
0234:
0235: @Override
0236: public WSDLComponent create(WSDLComponent context,
0237: Element element) {
0238: return new IssuedTokenImpl(context.getModel(), element);
0239: }
0240: }
0241:
0242: public static class KerberosTokenFactory extends ElementFactory {
0243: @Override
0244: public Set<QName> getElementQNames() {
0245: return Collections.singleton(TokensQName.KERBEROSTOKEN
0246: .getQName());
0247: }
0248:
0249: public <C extends WSDLComponent> C create(
0250: WSDLComponent context, Class<C> type) {
0251: return type.cast(new KerberosTokenImpl(context.getModel()));
0252: }
0253:
0254: @Override
0255: public WSDLComponent create(WSDLComponent context,
0256: Element element) {
0257: return new KerberosTokenImpl(context.getModel(), element);
0258: }
0259: }
0260:
0261: public static class ProtectionTokenFactory extends ElementFactory {
0262: @Override
0263: public Set<QName> getElementQNames() {
0264: return Collections.singleton(TokensQName.PROTECTIONTOKEN
0265: .getQName());
0266: }
0267:
0268: public <C extends WSDLComponent> C create(
0269: WSDLComponent context, Class<C> type) {
0270: return type
0271: .cast(new ProtectionTokenImpl(context.getModel()));
0272: }
0273:
0274: @Override
0275: public WSDLComponent create(WSDLComponent context,
0276: Element element) {
0277: return new ProtectionTokenImpl(context.getModel(), element);
0278: }
0279: }
0280:
0281: public static class TransportTokenFactory extends ElementFactory {
0282: @Override
0283: public Set<QName> getElementQNames() {
0284: return Collections.singleton(TokensQName.TRANSPORTTOKEN
0285: .getQName());
0286: }
0287:
0288: public <C extends WSDLComponent> C create(
0289: WSDLComponent context, Class<C> type) {
0290: return type
0291: .cast(new TransportTokenImpl(context.getModel()));
0292: }
0293:
0294: @Override
0295: public WSDLComponent create(WSDLComponent context,
0296: Element element) {
0297: return new TransportTokenImpl(context.getModel(), element);
0298: }
0299: }
0300:
0301: public static class RecipientTokenFactory extends ElementFactory {
0302: @Override
0303: public Set<QName> getElementQNames() {
0304: return Collections.singleton(TokensQName.RECIPIENTTOKEN
0305: .getQName());
0306: }
0307:
0308: public <C extends WSDLComponent> C create(
0309: WSDLComponent context, Class<C> type) {
0310: return type
0311: .cast(new RecipientTokenImpl(context.getModel()));
0312: }
0313:
0314: @Override
0315: public WSDLComponent create(WSDLComponent context,
0316: Element element) {
0317: return new RecipientTokenImpl(context.getModel(), element);
0318: }
0319: }
0320:
0321: public static class RelTokenFactory extends ElementFactory {
0322: @Override
0323: public Set<QName> getElementQNames() {
0324: return Collections.singleton(TokensQName.RELTOKEN
0325: .getQName());
0326: }
0327:
0328: public <C extends WSDLComponent> C create(
0329: WSDLComponent context, Class<C> type) {
0330: return type.cast(new RelTokenImpl(context.getModel()));
0331: }
0332:
0333: @Override
0334: public WSDLComponent create(WSDLComponent context,
0335: Element element) {
0336: return new RelTokenImpl(context.getModel(), element);
0337: }
0338: }
0339:
0340: public static class SamlTokenFactory extends ElementFactory {
0341: @Override
0342: public Set<QName> getElementQNames() {
0343: return Collections.singleton(TokensQName.SAMLTOKEN
0344: .getQName());
0345: }
0346:
0347: public <C extends WSDLComponent> C create(
0348: WSDLComponent context, Class<C> type) {
0349: return type.cast(new SamlTokenImpl(context.getModel()));
0350: }
0351:
0352: @Override
0353: public WSDLComponent create(WSDLComponent context,
0354: Element element) {
0355: return new SamlTokenImpl(context.getModel(), element);
0356: }
0357: }
0358:
0359: public static class SecureConversationTokenFactory extends
0360: ElementFactory {
0361: @Override
0362: public Set<QName> getElementQNames() {
0363: return Collections
0364: .singleton(TokensQName.SECURECONVERSATIONTOKEN
0365: .getQName());
0366: }
0367:
0368: public <C extends WSDLComponent> C create(
0369: WSDLComponent context, Class<C> type) {
0370: return type.cast(new SecureConversationTokenImpl(context
0371: .getModel()));
0372: }
0373:
0374: @Override
0375: public WSDLComponent create(WSDLComponent context,
0376: Element element) {
0377: return new SecureConversationTokenImpl(context.getModel(),
0378: element);
0379: }
0380: }
0381:
0382: public static class SecurityContextTokenFactory extends
0383: ElementFactory {
0384: @Override
0385: public Set<QName> getElementQNames() {
0386: return Collections
0387: .singleton(TokensQName.SECURITYCONTEXTTOKEN
0388: .getQName());
0389: }
0390:
0391: public <C extends WSDLComponent> C create(
0392: WSDLComponent context, Class<C> type) {
0393: return type.cast(new SecurityContextTokenImpl(context
0394: .getModel()));
0395: }
0396:
0397: @Override
0398: public WSDLComponent create(WSDLComponent context,
0399: Element element) {
0400: return new SecurityContextTokenImpl(context.getModel(),
0401: element);
0402: }
0403: }
0404:
0405: public static class SpnegoContextTokenFactory extends
0406: ElementFactory {
0407: @Override
0408: public Set<QName> getElementQNames() {
0409: return Collections.singleton(TokensQName.SPNEGOCONTEXTTOKEN
0410: .getQName());
0411: }
0412:
0413: public <C extends WSDLComponent> C create(
0414: WSDLComponent context, Class<C> type) {
0415: return type.cast(new SpnegoContextTokenImpl(context
0416: .getModel()));
0417: }
0418:
0419: @Override
0420: public WSDLComponent create(WSDLComponent context,
0421: Element element) {
0422: return new SpnegoContextTokenImpl(context.getModel(),
0423: element);
0424: }
0425: }
0426:
0427: public static class UsernameTokenFactory extends ElementFactory {
0428: @Override
0429: public Set<QName> getElementQNames() {
0430: return Collections.singleton(TokensQName.USERNAMETOKEN
0431: .getQName());
0432: }
0433:
0434: public <C extends WSDLComponent> C create(
0435: WSDLComponent context, Class<C> type) {
0436: return type.cast(new UsernameTokenImpl(context.getModel()));
0437: }
0438:
0439: @Override
0440: public WSDLComponent create(WSDLComponent context,
0441: Element element) {
0442: return new UsernameTokenImpl(context.getModel(), element);
0443: }
0444: }
0445:
0446: public static class X509TokenFactory extends ElementFactory {
0447: @Override
0448: public Set<QName> getElementQNames() {
0449: return Collections.singleton(TokensQName.X509TOKEN
0450: .getQName());
0451: }
0452:
0453: public <C extends WSDLComponent> C create(
0454: WSDLComponent context, Class<C> type) {
0455: return type.cast(new X509TokenImpl(context.getModel()));
0456: }
0457:
0458: @Override
0459: public WSDLComponent create(WSDLComponent context,
0460: Element element) {
0461: return new X509TokenImpl(context.getModel(), element);
0462: }
0463: }
0464:
0465: public static class WssUsernameToken10Factory extends
0466: ElementFactory {
0467: @Override
0468: public Set<QName> getElementQNames() {
0469: return Collections.singleton(TokensQName.WSSUSERNAMETOKEN10
0470: .getQName());
0471: }
0472:
0473: public <C extends WSDLComponent> C create(
0474: WSDLComponent context, Class<C> type) {
0475: return type.cast(new WssUsernameToken10Impl(context
0476: .getModel()));
0477: }
0478:
0479: @Override
0480: public WSDLComponent create(WSDLComponent context,
0481: Element element) {
0482: return new WssUsernameToken10Impl(context.getModel(),
0483: element);
0484: }
0485: }
0486:
0487: public static class WssUsernameToken11Factory extends
0488: ElementFactory {
0489: @Override
0490: public Set<QName> getElementQNames() {
0491: return Collections.singleton(TokensQName.WSSUSERNAMETOKEN11
0492: .getQName());
0493: }
0494:
0495: public <C extends WSDLComponent> C create(
0496: WSDLComponent context, Class<C> type) {
0497: return type.cast(new WssUsernameToken11Impl(context
0498: .getModel()));
0499: }
0500:
0501: @Override
0502: public WSDLComponent create(WSDLComponent context,
0503: Element element) {
0504: return new WssUsernameToken11Impl(context.getModel(),
0505: element);
0506: }
0507: }
0508:
0509: public static class IssuerFactory extends ElementFactory {
0510: @Override
0511: public Set<QName> getElementQNames() {
0512: return Collections.singleton(TokensQName.ISSUER.getQName());
0513: }
0514:
0515: public <C extends WSDLComponent> C create(
0516: WSDLComponent context, Class<C> type) {
0517: return type.cast(new IssuerImpl(context.getModel()));
0518: }
0519:
0520: @Override
0521: public WSDLComponent create(WSDLComponent context,
0522: Element element) {
0523: return new IssuerImpl(context.getModel(), element);
0524: }
0525: }
0526:
0527: public static class RequireDerivedKeysFactory extends
0528: ElementFactory {
0529: @Override
0530: public Set<QName> getElementQNames() {
0531: return Collections.singleton(TokensQName.REQUIREDERIVEDKEYS
0532: .getQName());
0533: }
0534:
0535: public <C extends WSDLComponent> C create(
0536: WSDLComponent context, Class<C> type) {
0537: return type.cast(new RequireDerivedKeysImpl(context
0538: .getModel()));
0539: }
0540:
0541: @Override
0542: public WSDLComponent create(WSDLComponent context,
0543: Element element) {
0544: return new RequireDerivedKeysImpl(context.getModel(),
0545: element);
0546: }
0547: }
0548:
0549: public static class RequireExternalReferenceFactory extends
0550: ElementFactory {
0551: @Override
0552: public Set<QName> getElementQNames() {
0553: return Collections
0554: .singleton(TokensQName.REQUIREEXTERNALREFERENCE
0555: .getQName());
0556: }
0557:
0558: public <C extends WSDLComponent> C create(
0559: WSDLComponent context, Class<C> type) {
0560: return type.cast(new RequireExternalReferenceImpl(context
0561: .getModel()));
0562: }
0563:
0564: @Override
0565: public WSDLComponent create(WSDLComponent context,
0566: Element element) {
0567: return new RequireExternalReferenceImpl(context.getModel(),
0568: element);
0569: }
0570: }
0571:
0572: public static class RequireInternalReferenceFactory extends
0573: ElementFactory {
0574: @Override
0575: public Set<QName> getElementQNames() {
0576: return Collections
0577: .singleton(TokensQName.REQUIREINTERNALREFERENCE
0578: .getQName());
0579: }
0580:
0581: public <C extends WSDLComponent> C create(
0582: WSDLComponent context, Class<C> type) {
0583: return type.cast(new RequireInternalReferenceImpl(context
0584: .getModel()));
0585: }
0586:
0587: @Override
0588: public WSDLComponent create(WSDLComponent context,
0589: Element element) {
0590: return new RequireInternalReferenceImpl(context.getModel(),
0591: element);
0592: }
0593: }
0594:
0595: public static class RequireKeyIdentifierReferenceFactory extends
0596: ElementFactory {
0597: @Override
0598: public Set<QName> getElementQNames() {
0599: return Collections
0600: .singleton(TokensQName.REQUIREKEYIDENTIFIERREFERENCE
0601: .getQName());
0602: }
0603:
0604: public <C extends WSDLComponent> C create(
0605: WSDLComponent context, Class<C> type) {
0606: return type.cast(new RequireKeyIdentifierReferenceImpl(
0607: context.getModel()));
0608: }
0609:
0610: @Override
0611: public WSDLComponent create(WSDLComponent context,
0612: Element element) {
0613: return new RequireKeyIdentifierReferenceImpl(context
0614: .getModel(), element);
0615: }
0616: }
0617:
0618: public static class RequireIssuerSerialReferenceFactory extends
0619: ElementFactory {
0620: @Override
0621: public Set<QName> getElementQNames() {
0622: return Collections
0623: .singleton(TokensQName.REQUIREISSUERSERIALREFERENCE
0624: .getQName());
0625: }
0626:
0627: public <C extends WSDLComponent> C create(
0628: WSDLComponent context, Class<C> type) {
0629: return type.cast(new RequireIssuerSerialReferenceImpl(
0630: context.getModel()));
0631: }
0632:
0633: @Override
0634: public WSDLComponent create(WSDLComponent context,
0635: Element element) {
0636: return new RequireIssuerSerialReferenceImpl(context
0637: .getModel(), element);
0638: }
0639: }
0640:
0641: public static class RequireThumbprintReferenceFactory extends
0642: ElementFactory {
0643: @Override
0644: public Set<QName> getElementQNames() {
0645: return Collections
0646: .singleton(TokensQName.REQUIRETHUMBPRINTREFERENCE
0647: .getQName());
0648: }
0649:
0650: public <C extends WSDLComponent> C create(
0651: WSDLComponent context, Class<C> type) {
0652: return type.cast(new RequireThumbprintReferenceImpl(context
0653: .getModel()));
0654: }
0655:
0656: @Override
0657: public WSDLComponent create(WSDLComponent context,
0658: Element element) {
0659: return new RequireThumbprintReferenceImpl(context
0660: .getModel(), element);
0661: }
0662: }
0663:
0664: public static class RequireEmbeddedTokenReferenceFactory extends
0665: ElementFactory {
0666: @Override
0667: public Set<QName> getElementQNames() {
0668: return Collections
0669: .singleton(TokensQName.REQUIREEMBEDDEDTOKENREFERENCE
0670: .getQName());
0671: }
0672:
0673: public <C extends WSDLComponent> C create(
0674: WSDLComponent context, Class<C> type) {
0675: return type.cast(new RequireEmbeddedTokenReferenceImpl(
0676: context.getModel()));
0677: }
0678:
0679: @Override
0680: public WSDLComponent create(WSDLComponent context,
0681: Element element) {
0682: return new RequireEmbeddedTokenReferenceImpl(context
0683: .getModel(), element);
0684: }
0685: }
0686:
0687: public static class RequireExternalUriReferenceFactory extends
0688: ElementFactory {
0689: @Override
0690: public Set<QName> getElementQNames() {
0691: return Collections
0692: .singleton(TokensQName.REQUIREEXTERNALURIREFERENCE
0693: .getQName());
0694: }
0695:
0696: public <C extends WSDLComponent> C create(
0697: WSDLComponent context, Class<C> type) {
0698: return type.cast(new RequireExternalUriReferenceImpl(
0699: context.getModel()));
0700: }
0701:
0702: @Override
0703: public WSDLComponent create(WSDLComponent context,
0704: Element element) {
0705: return new RequireExternalUriReferenceImpl(context
0706: .getModel(), element);
0707: }
0708: }
0709:
0710: public static class SC10SecurityContextTokenFactory extends
0711: ElementFactory {
0712: @Override
0713: public Set<QName> getElementQNames() {
0714: return Collections
0715: .singleton(TokensQName.SC10SECURITYCONTEXTTOKEN
0716: .getQName());
0717: }
0718:
0719: public <C extends WSDLComponent> C create(
0720: WSDLComponent context, Class<C> type) {
0721: return type.cast(new SC10SecurityContextTokenImpl(context
0722: .getModel()));
0723: }
0724:
0725: @Override
0726: public WSDLComponent create(WSDLComponent context,
0727: Element element) {
0728: return new SC10SecurityContextTokenImpl(context.getModel(),
0729: element);
0730: }
0731: }
0732:
0733: public static class WssX509V1Token10Factory extends ElementFactory {
0734: @Override
0735: public Set<QName> getElementQNames() {
0736: return Collections.singleton(TokensQName.WSSX509V1TOKEN10
0737: .getQName());
0738: }
0739:
0740: public <C extends WSDLComponent> C create(
0741: WSDLComponent context, Class<C> type) {
0742: return type.cast(new WssX509V1Token10Impl(context
0743: .getModel()));
0744: }
0745:
0746: @Override
0747: public WSDLComponent create(WSDLComponent context,
0748: Element element) {
0749: return new WssX509V1Token10Impl(context.getModel(), element);
0750: }
0751: }
0752:
0753: public static class WssX509V3Token10Factory extends ElementFactory {
0754: @Override
0755: public Set<QName> getElementQNames() {
0756: return Collections.singleton(TokensQName.WSSX509V3TOKEN10
0757: .getQName());
0758: }
0759:
0760: public <C extends WSDLComponent> C create(
0761: WSDLComponent context, Class<C> type) {
0762: return type.cast(new WssX509V3Token10Impl(context
0763: .getModel()));
0764: }
0765:
0766: @Override
0767: public WSDLComponent create(WSDLComponent context,
0768: Element element) {
0769: return new WssX509V3Token10Impl(context.getModel(), element);
0770: }
0771: }
0772:
0773: public static class WssX509Pkcs7Token10Factory extends
0774: ElementFactory {
0775: @Override
0776: public Set<QName> getElementQNames() {
0777: return Collections
0778: .singleton(TokensQName.WSSX509PKCS7TOKEN10
0779: .getQName());
0780: }
0781:
0782: public <C extends WSDLComponent> C create(
0783: WSDLComponent context, Class<C> type) {
0784: return type.cast(new WssX509Pkcs7Token10Impl(context
0785: .getModel()));
0786: }
0787:
0788: @Override
0789: public WSDLComponent create(WSDLComponent context,
0790: Element element) {
0791: return new WssX509Pkcs7Token10Impl(context.getModel(),
0792: element);
0793: }
0794: }
0795:
0796: public static class WssX509PkiPathV1Token10Factory extends
0797: ElementFactory {
0798: @Override
0799: public Set<QName> getElementQNames() {
0800: return Collections
0801: .singleton(TokensQName.WSSX509PKIPATHV1TOKEN10
0802: .getQName());
0803: }
0804:
0805: public <C extends WSDLComponent> C create(
0806: WSDLComponent context, Class<C> type) {
0807: return type.cast(new WssX509PkiPathV1Token10Impl(context
0808: .getModel()));
0809: }
0810:
0811: @Override
0812: public WSDLComponent create(WSDLComponent context,
0813: Element element) {
0814: return new WssX509PkiPathV1Token10Impl(context.getModel(),
0815: element);
0816: }
0817: }
0818:
0819: public static class WssX509V1Token11Factory extends ElementFactory {
0820: @Override
0821: public Set<QName> getElementQNames() {
0822: return Collections.singleton(TokensQName.WSSX509V1TOKEN11
0823: .getQName());
0824: }
0825:
0826: public <C extends WSDLComponent> C create(
0827: WSDLComponent context, Class<C> type) {
0828: return type.cast(new WssX509V1Token11Impl(context
0829: .getModel()));
0830: }
0831:
0832: @Override
0833: public WSDLComponent create(WSDLComponent context,
0834: Element element) {
0835: return new WssX509V1Token11Impl(context.getModel(), element);
0836: }
0837: }
0838:
0839: public static class WssX509V3Token11Factory extends ElementFactory {
0840: @Override
0841: public Set<QName> getElementQNames() {
0842: return Collections.singleton(TokensQName.WSSX509V3TOKEN11
0843: .getQName());
0844: }
0845:
0846: public <C extends WSDLComponent> C create(
0847: WSDLComponent context, Class<C> type) {
0848: return type.cast(new WssX509V3Token11Impl(context
0849: .getModel()));
0850: }
0851:
0852: @Override
0853: public WSDLComponent create(WSDLComponent context,
0854: Element element) {
0855: return new WssX509V3Token11Impl(context.getModel(), element);
0856: }
0857: }
0858:
0859: public static class WssX509Pkcs7Token11Factory extends
0860: ElementFactory {
0861: @Override
0862: public Set<QName> getElementQNames() {
0863: return Collections
0864: .singleton(TokensQName.WSSX509PKCS7TOKEN11
0865: .getQName());
0866: }
0867:
0868: public <C extends WSDLComponent> C create(
0869: WSDLComponent context, Class<C> type) {
0870: return type.cast(new WssX509Pkcs7Token11Impl(context
0871: .getModel()));
0872: }
0873:
0874: @Override
0875: public WSDLComponent create(WSDLComponent context,
0876: Element element) {
0877: return new WssX509Pkcs7Token11Impl(context.getModel(),
0878: element);
0879: }
0880: }
0881:
0882: public static class WssX509PkiPathV1Token11Factory extends
0883: ElementFactory {
0884: @Override
0885: public Set<QName> getElementQNames() {
0886: return Collections
0887: .singleton(TokensQName.WSSX509PKIPATHV1TOKEN11
0888: .getQName());
0889: }
0890:
0891: public <C extends WSDLComponent> C create(
0892: WSDLComponent context, Class<C> type) {
0893: return type.cast(new WssX509PkiPathV1Token11Impl(context
0894: .getModel()));
0895: }
0896:
0897: @Override
0898: public WSDLComponent create(WSDLComponent context,
0899: Element element) {
0900: return new WssX509PkiPathV1Token11Impl(context.getModel(),
0901: element);
0902: }
0903: }
0904:
0905: public static class WssSamlV10Token10Factory extends ElementFactory {
0906: @Override
0907: public Set<QName> getElementQNames() {
0908: return Collections.singleton(TokensQName.WSSSAMLV10TOKEN10
0909: .getQName());
0910: }
0911:
0912: public <C extends WSDLComponent> C create(
0913: WSDLComponent context, Class<C> type) {
0914: return type.cast(new WssSamlV10Token10Impl(context
0915: .getModel()));
0916: }
0917:
0918: @Override
0919: public WSDLComponent create(WSDLComponent context,
0920: Element element) {
0921: return new WssSamlV10Token10Impl(context.getModel(),
0922: element);
0923: }
0924: }
0925:
0926: public static class WssSamlV11Token10Factory extends ElementFactory {
0927: @Override
0928: public Set<QName> getElementQNames() {
0929: return Collections.singleton(TokensQName.WSSSAMLV11TOKEN10
0930: .getQName());
0931: }
0932:
0933: public <C extends WSDLComponent> C create(
0934: WSDLComponent context, Class<C> type) {
0935: return type.cast(new WssSamlV11Token10Impl(context
0936: .getModel()));
0937: }
0938:
0939: @Override
0940: public WSDLComponent create(WSDLComponent context,
0941: Element element) {
0942: return new WssSamlV11Token10Impl(context.getModel(),
0943: element);
0944: }
0945: }
0946:
0947: public static class WssSamlV10Token11Factory extends ElementFactory {
0948: @Override
0949: public Set<QName> getElementQNames() {
0950: return Collections.singleton(TokensQName.WSSSAMLV10TOKEN11
0951: .getQName());
0952: }
0953:
0954: public <C extends WSDLComponent> C create(
0955: WSDLComponent context, Class<C> type) {
0956: return type.cast(new WssSamlV10Token11Impl(context
0957: .getModel()));
0958: }
0959:
0960: @Override
0961: public WSDLComponent create(WSDLComponent context,
0962: Element element) {
0963: return new WssSamlV10Token11Impl(context.getModel(),
0964: element);
0965: }
0966: }
0967:
0968: public static class WssSamlV11Token11Factory extends ElementFactory {
0969: @Override
0970: public Set<QName> getElementQNames() {
0971: return Collections.singleton(TokensQName.WSSSAMLV11TOKEN11
0972: .getQName());
0973: }
0974:
0975: public <C extends WSDLComponent> C create(
0976: WSDLComponent context, Class<C> type) {
0977: return type.cast(new WssSamlV11Token11Impl(context
0978: .getModel()));
0979: }
0980:
0981: @Override
0982: public WSDLComponent create(WSDLComponent context,
0983: Element element) {
0984: return new WssSamlV11Token11Impl(context.getModel(),
0985: element);
0986: }
0987: }
0988:
0989: public static class WssSamlV20Token11Factory extends ElementFactory {
0990: @Override
0991: public Set<QName> getElementQNames() {
0992: return Collections.singleton(TokensQName.WSSSAMLV20TOKEN11
0993: .getQName());
0994: }
0995:
0996: public <C extends WSDLComponent> C create(
0997: WSDLComponent context, Class<C> type) {
0998: return type.cast(new WssSamlV20Token11Impl(context
0999: .getModel()));
1000: }
1001:
1002: @Override
1003: public WSDLComponent create(WSDLComponent context,
1004: Element element) {
1005: return new WssSamlV20Token11Impl(context.getModel(),
1006: element);
1007: }
1008: }
1009:
1010: public static class WssRelV10Token10Factory extends ElementFactory {
1011: @Override
1012: public Set<QName> getElementQNames() {
1013: return Collections.singleton(TokensQName.WSSRELV10TOKEN10
1014: .getQName());
1015: }
1016:
1017: public <C extends WSDLComponent> C create(
1018: WSDLComponent context, Class<C> type) {
1019: return type.cast(new WssRelV10Token10Impl(context
1020: .getModel()));
1021: }
1022:
1023: @Override
1024: public WSDLComponent create(WSDLComponent context,
1025: Element element) {
1026: return new WssRelV10Token10Impl(context.getModel(), element);
1027: }
1028: }
1029:
1030: public static class WssRelV20Token10Factory extends ElementFactory {
1031: @Override
1032: public Set<QName> getElementQNames() {
1033: return Collections.singleton(TokensQName.WSSRELV20TOKEN10
1034: .getQName());
1035: }
1036:
1037: public <C extends WSDLComponent> C create(
1038: WSDLComponent context, Class<C> type) {
1039: return type.cast(new WssRelV20Token10Impl(context
1040: .getModel()));
1041: }
1042:
1043: @Override
1044: public WSDLComponent create(WSDLComponent context,
1045: Element element) {
1046: return new WssRelV20Token10Impl(context.getModel(), element);
1047: }
1048: }
1049:
1050: public static class WssRelV10Token11Factory extends ElementFactory {
1051: @Override
1052: public Set<QName> getElementQNames() {
1053: return Collections.singleton(TokensQName.WSSRELV10TOKEN11
1054: .getQName());
1055: }
1056:
1057: public <C extends WSDLComponent> C create(
1058: WSDLComponent context, Class<C> type) {
1059: return type.cast(new WssRelV10Token11Impl(context
1060: .getModel()));
1061: }
1062:
1063: @Override
1064: public WSDLComponent create(WSDLComponent context,
1065: Element element) {
1066: return new WssRelV10Token11Impl(context.getModel(), element);
1067: }
1068: }
1069:
1070: public static class WssRelV20Token11Factory extends ElementFactory {
1071: @Override
1072: public Set<QName> getElementQNames() {
1073: return Collections.singleton(TokensQName.WSSRELV20TOKEN11
1074: .getQName());
1075: }
1076:
1077: public <C extends WSDLComponent> C create(
1078: WSDLComponent context, Class<C> type) {
1079: return type.cast(new WssRelV20Token11Impl(context
1080: .getModel()));
1081: }
1082:
1083: @Override
1084: public WSDLComponent create(WSDLComponent context,
1085: Element element) {
1086: return new WssRelV20Token11Impl(context.getModel(), element);
1087: }
1088: }
1089:
1090: public static class WssKerberosV5ApReqToken11Factory extends
1091: ElementFactory {
1092: @Override
1093: public Set<QName> getElementQNames() {
1094: return Collections
1095: .singleton(TokensQName.WSSKERBEROSV5APREQTOKEN11
1096: .getQName());
1097: }
1098:
1099: public <C extends WSDLComponent> C create(
1100: WSDLComponent context, Class<C> type) {
1101: return type.cast(new WssKerberosV5ApReqToken11Impl(context
1102: .getModel()));
1103: }
1104:
1105: @Override
1106: public WSDLComponent create(WSDLComponent context,
1107: Element element) {
1108: return new WssKerberosV5ApReqToken11Impl(
1109: context.getModel(), element);
1110: }
1111: }
1112:
1113: public static class WssGssKerberosV5ApReqToken11Factory extends
1114: ElementFactory {
1115: @Override
1116: public Set<QName> getElementQNames() {
1117: return Collections
1118: .singleton(TokensQName.WSSGSSKERBEROSV5APREQTOKEN11
1119: .getQName());
1120: }
1121:
1122: public <C extends WSDLComponent> C create(
1123: WSDLComponent context, Class<C> type) {
1124: return type.cast(new WssGssKerberosV5ApReqToken11Impl(
1125: context.getModel()));
1126: }
1127:
1128: @Override
1129: public WSDLComponent create(WSDLComponent context,
1130: Element element) {
1131: return new WssGssKerberosV5ApReqToken11Impl(context
1132: .getModel(), element);
1133: }
1134: }
1135: }
|