0001: /*
0002: * Created on Feb 5, 2004
0003: *
0004: * To change the template for this generated file go to
0005: * Window - Preferences - Java - Code Generation - Code and Comments
0006: */
0007: package org.geoserver.wfs.xml;
0008:
0009: import java.math.BigDecimal;
0010: import java.util.Date;
0011: import java.util.HashSet;
0012: import java.util.Set;
0013:
0014: /**
0015: * XMLSchemaTranslator purpose.
0016: * <p>
0017: * This instance of the NameSpaceTranslator should be used with http://www.w3.org/2001/XMLSchema namespace.
0018: * </p>
0019: * <p>
0020: * Instances of this object should always be retrieved through the NameSpaceTranslatorFactory.
0021: * </p>
0022: * <p>
0023: * Added a bit of a hack to get the right default mappings. Added isDefault to
0024: * the classes we want. Note that this list comes from
0025: * org.geotools.gml.producer.FeatureTypeTransformer.
0026: * </p>
0027: * @see NameSpaceTranslatorFactory
0028: *
0029: * @author dzwiers, Refractions Research, Inc.
0030: * @author $Author: dmzwiers $ (last modification)
0031: * @version $Id: XMLSchemaTranslator.java 6177 2007-02-19 10:11:27Z aaime $
0032: */
0033: public class XMLSchemaTranslator extends NameSpaceTranslator {
0034: private HashSet elements;
0035:
0036: /**
0037: * XMLSchemaTranslator constructor.
0038: * <p>
0039: * Description
0040: * </p>
0041: * @param prefix
0042: */
0043: public XMLSchemaTranslator(String prefix) {
0044: super (prefix);
0045: elements = new HashSet();
0046: elements.add(new BooleanElement(prefix));
0047: elements.add(new DecimalElement(prefix));
0048: elements.add(new IntegerElement(prefix));
0049: elements.add(new NegativeIntegerElement(prefix));
0050: elements.add(new NonNegativeIntegerElement(prefix));
0051: elements.add(new PositiveIntegerElement(prefix));
0052: elements.add(new LongElement(prefix));
0053: elements.add(new IntElement(prefix));
0054: elements.add(new ShortElement(prefix));
0055: elements.add(new ByteElement(prefix));
0056: elements.add(new UnsignedLongElement(prefix));
0057: elements.add(new UnsignedShortElement(prefix));
0058: elements.add(new UnsignedIntElement(prefix));
0059: elements.add(new UnsignedByteElement(prefix));
0060: elements.add(new FloatElement(prefix));
0061: elements.add(new DoubleElement(prefix));
0062: elements.add(new DateElement(prefix));
0063: elements.add(new DateTimeElement(prefix));
0064: elements.add(new DurationElement(prefix));
0065: elements.add(new GDayElement(prefix));
0066: elements.add(new GMonthElement(prefix));
0067: elements.add(new GMonthDayElement(prefix));
0068: elements.add(new GYearElement(prefix));
0069: elements.add(new GYearMonthElement(prefix));
0070: elements.add(new TimeElement(prefix));
0071: elements.add(new IDElement(prefix));
0072: elements.add(new IDREFElement(prefix));
0073: elements.add(new IDREFSElement(prefix));
0074: elements.add(new ENTITYElement(prefix));
0075: elements.add(new ENTITIESElement(prefix));
0076: elements.add(new NMTOKENElement(prefix));
0077: elements.add(new NMTOKENSElement(prefix));
0078: elements.add(new NOTATIONElement(prefix));
0079: elements.add(new StringElement(prefix));
0080: elements.add(new NormalizedStringElement(prefix));
0081: elements.add(new TokenElement(prefix));
0082: elements.add(new QNameElement(prefix));
0083: elements.add(new NameElement(prefix));
0084: elements.add(new NCNameElement(prefix));
0085: }
0086:
0087: /**
0088: * Implementation of getElements.
0089: *
0090: * @see org.vfny.geoserver.global.xml.NameSpaceTranslator#getElements()
0091: *
0092: * @return
0093: */
0094: public Set getElements() {
0095: return elements;
0096: }
0097:
0098: /**
0099: * Implementation of getNameSpace.
0100: *
0101: * @see org.vfny.geoserver.global.xml.NameSpaceTranslator#getNameSpace()
0102: *
0103: * @return
0104: */
0105: public String getNameSpace() {
0106: return "http://www.w3.org/2001/XMLSchema";
0107: }
0108: }
0109:
0110: class BooleanElement extends NameSpaceElement {
0111: public BooleanElement(String prefix) {
0112: super (prefix);
0113: }
0114:
0115: public String getTypeDefName() {
0116: return "boolean";
0117: }
0118:
0119: public String getTypeRefName() {
0120: return "boolean";
0121: }
0122:
0123: public String getQualifiedTypeDefName() {
0124: return prefix + ":boolean";
0125: }
0126:
0127: public String getQualifiedTypeRefName() {
0128: return prefix + ":boolean";
0129: }
0130:
0131: public String getQualifiedTypeDefName(String prefix) {
0132: if (prefix != null) {
0133: return prefix + ":boolean";
0134: }
0135:
0136: if (this .prefix != null) {
0137: return this .prefix + ":boolean";
0138: }
0139:
0140: return null;
0141: }
0142:
0143: public String getQualifiedTypeRefName(String prefix) {
0144: if (prefix != null) {
0145: return prefix + ":boolean";
0146: }
0147:
0148: if (this .prefix != null) {
0149: return this .prefix + ":boolean";
0150: }
0151:
0152: return null;
0153: }
0154:
0155: public Class getJavaClass() {
0156: return Boolean.class;
0157: }
0158:
0159: public boolean isAbstract() {
0160: return false;
0161: }
0162: }
0163:
0164: class DecimalElement extends NameSpaceElement {
0165: public DecimalElement(String prefix) {
0166: super (prefix);
0167: }
0168:
0169: public String getTypeDefName() {
0170: return "decimal";
0171: }
0172:
0173: public String getTypeRefName() {
0174: return "decimal";
0175: }
0176:
0177: public String getQualifiedTypeDefName() {
0178: return prefix + ":decimal";
0179: }
0180:
0181: public String getQualifiedTypeRefName() {
0182: return prefix + ":decimal";
0183: }
0184:
0185: public String getQualifiedTypeDefName(String prefix) {
0186: if (prefix != null) {
0187: return prefix + ":decimal";
0188: }
0189:
0190: if (this .prefix != null) {
0191: return this .prefix + ":decimal";
0192: }
0193:
0194: return null;
0195: }
0196:
0197: public String getQualifiedTypeRefName(String prefix) {
0198: if (prefix != null) {
0199: return prefix + ":decimal";
0200: }
0201:
0202: if (this .prefix != null) {
0203: return this .prefix + ":decimal";
0204: }
0205:
0206: return null;
0207: }
0208:
0209: public Class getJavaClass() {
0210: return BigDecimal.class;
0211: }
0212:
0213: public boolean isAbstract() {
0214: return false;
0215: }
0216:
0217: public boolean isDefault() {
0218: return true;
0219: }
0220: }
0221:
0222: class IntegerElement extends NameSpaceElement {
0223: public IntegerElement(String prefix) {
0224: super (prefix);
0225: }
0226:
0227: public String getTypeDefName() {
0228: return "integer";
0229: }
0230:
0231: public String getTypeRefName() {
0232: return "integer";
0233: }
0234:
0235: public String getQualifiedTypeDefName() {
0236: return prefix + ":integer";
0237: }
0238:
0239: public String getQualifiedTypeRefName() {
0240: return prefix + ":integer";
0241: }
0242:
0243: public String getQualifiedTypeDefName(String prefix) {
0244: if (prefix != null) {
0245: return prefix + ":integer";
0246: }
0247:
0248: if (this .prefix != null) {
0249: return this .prefix + ":integer";
0250: }
0251:
0252: return null;
0253: }
0254:
0255: public String getQualifiedTypeRefName(String prefix) {
0256: if (prefix != null) {
0257: return prefix + ":integer";
0258: }
0259:
0260: if (this .prefix != null) {
0261: return this .prefix + ":integer";
0262: }
0263:
0264: return null;
0265: }
0266:
0267: public Class getJavaClass() {
0268: return Integer.class;
0269: }
0270:
0271: public boolean isAbstract() {
0272: return false;
0273: }
0274: }
0275:
0276: class NegativeIntegerElement extends NameSpaceElement {
0277: public NegativeIntegerElement(String prefix) {
0278: super (prefix);
0279: }
0280:
0281: public String getTypeDefName() {
0282: return "negativeInteger";
0283: }
0284:
0285: public String getTypeRefName() {
0286: return "negativeInteger";
0287: }
0288:
0289: public String getQualifiedTypeDefName() {
0290: return prefix + ":negativeInteger";
0291: }
0292:
0293: public String getQualifiedTypeRefName() {
0294: return prefix + ":negativeInteger";
0295: }
0296:
0297: public String getQualifiedTypeDefName(String prefix) {
0298: if (prefix != null) {
0299: return prefix + ":negativeInteger";
0300: }
0301:
0302: if (this .prefix != null) {
0303: return this .prefix + ":negativeInteger";
0304: }
0305:
0306: return null;
0307: }
0308:
0309: public String getQualifiedTypeRefName(String prefix) {
0310: if (prefix != null) {
0311: return prefix + ":negativeInteger";
0312: }
0313:
0314: if (this .prefix != null) {
0315: return this .prefix + ":negativeInteger";
0316: }
0317:
0318: return null;
0319: }
0320:
0321: public Class getJavaClass() {
0322: return Integer.class;
0323: }
0324:
0325: public boolean isAbstract() {
0326: return false;
0327: }
0328: }
0329:
0330: class NonNegativeIntegerElement extends NameSpaceElement {
0331: public NonNegativeIntegerElement(String prefix) {
0332: super (prefix);
0333: }
0334:
0335: public String getTypeDefName() {
0336: return "nonNegativeInteger";
0337: }
0338:
0339: public String getTypeRefName() {
0340: return "nonNegativeInteger";
0341: }
0342:
0343: public String getQualifiedTypeDefName() {
0344: return prefix + ":nonNegativeInteger";
0345: }
0346:
0347: public String getQualifiedTypeRefName() {
0348: return prefix + ":nonNegativeInteger";
0349: }
0350:
0351: public String getQualifiedTypeDefName(String prefix) {
0352: if (prefix != null) {
0353: return prefix + ":nonNegativeInteger";
0354: }
0355:
0356: if (this .prefix != null) {
0357: return this .prefix + ":nonNegativeInteger";
0358: }
0359:
0360: return null;
0361: }
0362:
0363: public String getQualifiedTypeRefName(String prefix) {
0364: if (prefix != null) {
0365: return prefix + ":nonNegativeInteger";
0366: }
0367:
0368: if (this .prefix != null) {
0369: return this .prefix + ":nonNegativeInteger";
0370: }
0371:
0372: return null;
0373: }
0374:
0375: public Class getJavaClass() {
0376: return Integer.class;
0377: }
0378:
0379: public boolean isAbstract() {
0380: return false;
0381: }
0382: }
0383:
0384: class PositiveIntegerElement extends NameSpaceElement {
0385: public PositiveIntegerElement(String prefix) {
0386: super (prefix);
0387: }
0388:
0389: public String getTypeDefName() {
0390: return "positiveInteger";
0391: }
0392:
0393: public String getTypeRefName() {
0394: return "positiveInteger";
0395: }
0396:
0397: public String getQualifiedTypeDefName() {
0398: return prefix + ":positiveInteger";
0399: }
0400:
0401: public String getQualifiedTypeRefName() {
0402: return prefix + ":positiveInteger";
0403: }
0404:
0405: public String getQualifiedTypeDefName(String prefix) {
0406: if (prefix != null) {
0407: return prefix + ":positiveInteger";
0408: }
0409:
0410: if (this .prefix != null) {
0411: return this .prefix + ":positiveInteger";
0412: }
0413:
0414: return null;
0415: }
0416:
0417: public String getQualifiedTypeRefName(String prefix) {
0418: if (prefix != null) {
0419: return prefix + ":positiveInteger";
0420: }
0421:
0422: if (this .prefix != null) {
0423: return this .prefix + ":positiveInteger";
0424: }
0425:
0426: return null;
0427: }
0428:
0429: public Class getJavaClass() {
0430: return Integer.class;
0431: }
0432:
0433: public boolean isAbstract() {
0434: return false;
0435: }
0436: }
0437:
0438: class LongElement extends NameSpaceElement {
0439: public LongElement(String prefix) {
0440: super (prefix);
0441: }
0442:
0443: public String getTypeDefName() {
0444: return "long";
0445: }
0446:
0447: public String getTypeRefName() {
0448: return "long";
0449: }
0450:
0451: public String getQualifiedTypeDefName() {
0452: return prefix + ":long";
0453: }
0454:
0455: public String getQualifiedTypeRefName() {
0456: return prefix + ":long";
0457: }
0458:
0459: public String getQualifiedTypeDefName(String prefix) {
0460: if (prefix != null) {
0461: return prefix + ":long";
0462: }
0463:
0464: if (this .prefix != null) {
0465: return this .prefix + ":long";
0466: }
0467:
0468: return null;
0469: }
0470:
0471: public String getQualifiedTypeRefName(String prefix) {
0472: if (prefix != null) {
0473: return prefix + ":long";
0474: }
0475:
0476: if (this .prefix != null) {
0477: return this .prefix + ":long";
0478: }
0479:
0480: return null;
0481: }
0482:
0483: public Class getJavaClass() {
0484: return Long.class;
0485: }
0486:
0487: public boolean isAbstract() {
0488: return false;
0489: }
0490:
0491: public boolean isDefault() {
0492: return true;
0493: }
0494: }
0495:
0496: class IntElement extends NameSpaceElement {
0497: public IntElement(String prefix) {
0498: super (prefix);
0499: }
0500:
0501: public String getTypeDefName() {
0502: return "int";
0503: }
0504:
0505: public String getTypeRefName() {
0506: return "int";
0507: }
0508:
0509: public String getQualifiedTypeDefName() {
0510: return prefix + ":int";
0511: }
0512:
0513: public String getQualifiedTypeRefName() {
0514: return prefix + ":int";
0515: }
0516:
0517: public String getQualifiedTypeDefName(String prefix) {
0518: if (prefix != null) {
0519: return prefix + ":int";
0520: }
0521:
0522: if (this .prefix != null) {
0523: return this .prefix + ":int";
0524: }
0525:
0526: return null;
0527: }
0528:
0529: public String getQualifiedTypeRefName(String prefix) {
0530: if (prefix != null) {
0531: return prefix + ":int";
0532: }
0533:
0534: if (this .prefix != null) {
0535: return this .prefix + ":int";
0536: }
0537:
0538: return null;
0539: }
0540:
0541: public Class getJavaClass() {
0542: return Integer.class;
0543: }
0544:
0545: public boolean isAbstract() {
0546: return false;
0547: }
0548:
0549: public boolean isDefault() {
0550: return true;
0551: }
0552: }
0553:
0554: class ShortElement extends NameSpaceElement {
0555: public ShortElement(String prefix) {
0556: super (prefix);
0557: }
0558:
0559: public String getTypeDefName() {
0560: return "short";
0561: }
0562:
0563: public String getTypeRefName() {
0564: return "short";
0565: }
0566:
0567: public String getQualifiedTypeDefName() {
0568: return prefix + ":short";
0569: }
0570:
0571: public String getQualifiedTypeRefName() {
0572: return prefix + ":short";
0573: }
0574:
0575: public String getQualifiedTypeDefName(String prefix) {
0576: if (prefix != null) {
0577: return prefix + ":short";
0578: }
0579:
0580: if (this .prefix != null) {
0581: return this .prefix + ":short";
0582: }
0583:
0584: return null;
0585: }
0586:
0587: public String getQualifiedTypeRefName(String prefix) {
0588: if (prefix != null) {
0589: return prefix + ":short";
0590: }
0591:
0592: if (this .prefix != null) {
0593: return this .prefix + ":short";
0594: }
0595:
0596: return null;
0597: }
0598:
0599: public Class getJavaClass() {
0600: return Short.class;
0601: }
0602:
0603: public boolean isAbstract() {
0604: return false;
0605: }
0606:
0607: public boolean isDefault() {
0608: return true;
0609: }
0610: }
0611:
0612: class ByteElement extends NameSpaceElement {
0613: public ByteElement(String prefix) {
0614: super (prefix);
0615: }
0616:
0617: public String getTypeDefName() {
0618: return "byte";
0619: }
0620:
0621: public String getTypeRefName() {
0622: return "byte";
0623: }
0624:
0625: public String getQualifiedTypeDefName() {
0626: return prefix + ":byte";
0627: }
0628:
0629: public String getQualifiedTypeRefName() {
0630: return prefix + ":byte";
0631: }
0632:
0633: public String getQualifiedTypeDefName(String prefix) {
0634: if (prefix != null) {
0635: return prefix + ":byte";
0636: }
0637:
0638: if (this .prefix != null) {
0639: return this .prefix + ":byte";
0640: }
0641:
0642: return null;
0643: }
0644:
0645: public String getQualifiedTypeRefName(String prefix) {
0646: if (prefix != null) {
0647: return prefix + ":byte";
0648: }
0649:
0650: if (this .prefix != null) {
0651: return this .prefix + ":byte";
0652: }
0653:
0654: return null;
0655: }
0656:
0657: public Class getJavaClass() {
0658: return Byte.class;
0659: }
0660:
0661: public boolean isAbstract() {
0662: return false;
0663: }
0664:
0665: public boolean isDefault() {
0666: return true;
0667: }
0668: }
0669:
0670: class UnsignedLongElement extends NameSpaceElement {
0671: public UnsignedLongElement(String prefix) {
0672: super (prefix);
0673: }
0674:
0675: public String getTypeDefName() {
0676: return "unsignedLong";
0677: }
0678:
0679: public String getTypeRefName() {
0680: return "unsignedLong";
0681: }
0682:
0683: public String getQualifiedTypeDefName() {
0684: return prefix + ":unsignedLong";
0685: }
0686:
0687: public String getQualifiedTypeRefName() {
0688: return prefix + ":unsignedLong";
0689: }
0690:
0691: public String getQualifiedTypeDefName(String prefix) {
0692: if (prefix != null) {
0693: return prefix + ":unsignedLong";
0694: }
0695:
0696: if (this .prefix != null) {
0697: return this .prefix + ":unsignedLong";
0698: }
0699:
0700: return null;
0701: }
0702:
0703: public String getQualifiedTypeRefName(String prefix) {
0704: if (prefix != null) {
0705: return prefix + ":unsignedLong";
0706: }
0707:
0708: if (this .prefix != null) {
0709: return this .prefix + ":unsignedLong";
0710: }
0711:
0712: return null;
0713: }
0714:
0715: public Class getJavaClass() {
0716: return Long.class;
0717: }
0718:
0719: public boolean isAbstract() {
0720: return false;
0721: }
0722: }
0723:
0724: class UnsignedShortElement extends NameSpaceElement {
0725: public UnsignedShortElement(String prefix) {
0726: super (prefix);
0727: }
0728:
0729: public String getTypeDefName() {
0730: return "unsignedShort";
0731: }
0732:
0733: public String getTypeRefName() {
0734: return "unsignedShort";
0735: }
0736:
0737: public String getQualifiedTypeDefName() {
0738: return prefix + ":unsignedShort";
0739: }
0740:
0741: public String getQualifiedTypeRefName() {
0742: return prefix + ":unsignedShort";
0743: }
0744:
0745: public String getQualifiedTypeDefName(String prefix) {
0746: if (prefix != null) {
0747: return prefix + ":unsignedShort";
0748: }
0749:
0750: if (this .prefix != null) {
0751: return this .prefix + ":unsignedShort";
0752: }
0753:
0754: return null;
0755: }
0756:
0757: public String getQualifiedTypeRefName(String prefix) {
0758: if (prefix != null) {
0759: return prefix + ":unsignedShort";
0760: }
0761:
0762: if (this .prefix != null) {
0763: return this .prefix + ":unsignedShort";
0764: }
0765:
0766: return null;
0767: }
0768:
0769: public Class getJavaClass() {
0770: return Short.class;
0771: }
0772:
0773: public boolean isAbstract() {
0774: return false;
0775: }
0776: }
0777:
0778: class UnsignedIntElement extends NameSpaceElement {
0779: public UnsignedIntElement(String prefix) {
0780: super (prefix);
0781: }
0782:
0783: public String getTypeDefName() {
0784: return "unsignedInt";
0785: }
0786:
0787: public String getTypeRefName() {
0788: return "unsignedInt";
0789: }
0790:
0791: public String getQualifiedTypeDefName() {
0792: return prefix + ":unsignedInt";
0793: }
0794:
0795: public String getQualifiedTypeRefName() {
0796: return prefix + ":unsignedInt";
0797: }
0798:
0799: public String getQualifiedTypeDefName(String prefix) {
0800: if (prefix != null) {
0801: return prefix + ":unsignedInt";
0802: }
0803:
0804: if (this .prefix != null) {
0805: return this .prefix + ":unsignedInt";
0806: }
0807:
0808: return null;
0809: }
0810:
0811: public String getQualifiedTypeRefName(String prefix) {
0812: if (prefix != null) {
0813: return prefix + ":unsignedInt";
0814: }
0815:
0816: if (this .prefix != null) {
0817: return this .prefix + ":unsignedInt";
0818: }
0819:
0820: return null;
0821: }
0822:
0823: public Class getJavaClass() {
0824: return Integer.class;
0825: }
0826:
0827: public boolean isAbstract() {
0828: return false;
0829: }
0830: }
0831:
0832: class UnsignedByteElement extends NameSpaceElement {
0833: public UnsignedByteElement(String prefix) {
0834: super (prefix);
0835: }
0836:
0837: public String getTypeDefName() {
0838: return "unsignedByte";
0839: }
0840:
0841: public String getTypeRefName() {
0842: return "unsignedByte";
0843: }
0844:
0845: public String getQualifiedTypeDefName() {
0846: return prefix + ":unsignedByte";
0847: }
0848:
0849: public String getQualifiedTypeRefName() {
0850: return prefix + ":unsignedByte";
0851: }
0852:
0853: public String getQualifiedTypeDefName(String prefix) {
0854: if (prefix != null) {
0855: return prefix + ":unsignedByte";
0856: }
0857:
0858: if (this .prefix != null) {
0859: return this .prefix + ":unsignedByte";
0860: }
0861:
0862: return null;
0863: }
0864:
0865: public String getQualifiedTypeRefName(String prefix) {
0866: if (prefix != null) {
0867: return prefix + ":unsignedByte";
0868: }
0869:
0870: if (this .prefix != null) {
0871: return this .prefix + ":unsignedByte";
0872: }
0873:
0874: return null;
0875: }
0876:
0877: public Class getJavaClass() {
0878: return Byte.class;
0879: }
0880:
0881: public boolean isAbstract() {
0882: return false;
0883: }
0884: }
0885:
0886: class FloatElement extends NameSpaceElement {
0887: public FloatElement(String prefix) {
0888: super (prefix);
0889: }
0890:
0891: public String getTypeDefName() {
0892: return "float";
0893: }
0894:
0895: public String getTypeRefName() {
0896: return "float";
0897: }
0898:
0899: public String getQualifiedTypeDefName() {
0900: return prefix + ":float";
0901: }
0902:
0903: public String getQualifiedTypeRefName() {
0904: return prefix + ":float";
0905: }
0906:
0907: public String getQualifiedTypeDefName(String prefix) {
0908: if (prefix != null) {
0909: return prefix + ":float";
0910: }
0911:
0912: if (this .prefix != null) {
0913: return this .prefix + ":float";
0914: }
0915:
0916: return null;
0917: }
0918:
0919: public String getQualifiedTypeRefName(String prefix) {
0920: if (prefix != null) {
0921: return prefix + ":float";
0922: }
0923:
0924: if (this .prefix != null) {
0925: return this .prefix + ":float";
0926: }
0927:
0928: return null;
0929: }
0930:
0931: public Class getJavaClass() {
0932: return Float.class;
0933: }
0934:
0935: public boolean isAbstract() {
0936: return false;
0937: }
0938:
0939: public boolean isDefault() {
0940: return true;
0941: }
0942: }
0943:
0944: class DoubleElement extends NameSpaceElement {
0945: public DoubleElement(String prefix) {
0946: super (prefix);
0947: }
0948:
0949: public String getTypeDefName() {
0950: return "double";
0951: }
0952:
0953: public String getTypeRefName() {
0954: return "double";
0955: }
0956:
0957: public String getQualifiedTypeDefName() {
0958: return prefix + ":double";
0959: }
0960:
0961: public String getQualifiedTypeRefName() {
0962: return prefix + ":double";
0963: }
0964:
0965: public String getQualifiedTypeDefName(String prefix) {
0966: if (prefix != null) {
0967: return prefix + ":double";
0968: }
0969:
0970: if (this .prefix != null) {
0971: return this .prefix + ":double";
0972: }
0973:
0974: return null;
0975: }
0976:
0977: public String getQualifiedTypeRefName(String prefix) {
0978: if (prefix != null) {
0979: return prefix + ":double";
0980: }
0981:
0982: if (this .prefix != null) {
0983: return this .prefix + ":double";
0984: }
0985:
0986: return null;
0987: }
0988:
0989: public Class getJavaClass() {
0990: return Double.class;
0991: }
0992:
0993: public boolean isAbstract() {
0994: return false;
0995: }
0996:
0997: public boolean isDefault() {
0998: return true;
0999: }
1000: }
1001:
1002: class DateElement extends NameSpaceElement {
1003: public DateElement(String prefix) {
1004: super (prefix);
1005: }
1006:
1007: public String getTypeDefName() {
1008: return "date";
1009: }
1010:
1011: public String getTypeRefName() {
1012: return "date";
1013: }
1014:
1015: public String getQualifiedTypeDefName() {
1016: return prefix + ":date";
1017: }
1018:
1019: public String getQualifiedTypeRefName() {
1020: return prefix + ":date";
1021: }
1022:
1023: public String getQualifiedTypeDefName(String prefix) {
1024: if (prefix != null) {
1025: return prefix + ":date";
1026: }
1027:
1028: if (this .prefix != null) {
1029: return this .prefix + ":date";
1030: }
1031:
1032: return null;
1033: }
1034:
1035: public String getQualifiedTypeRefName(String prefix) {
1036: if (prefix != null) {
1037: return prefix + ":date";
1038: }
1039:
1040: if (this .prefix != null) {
1041: return this .prefix + ":date";
1042: }
1043:
1044: return null;
1045: }
1046:
1047: public Class getJavaClass() {
1048: return Date.class;
1049: }
1050:
1051: public boolean isAbstract() {
1052: return false;
1053: }
1054: }
1055:
1056: class DateTimeElement extends NameSpaceElement {
1057: public DateTimeElement(String prefix) {
1058: super (prefix);
1059: }
1060:
1061: public String getTypeDefName() {
1062: return "dateTime";
1063: }
1064:
1065: public String getTypeRefName() {
1066: return "dateTime";
1067: }
1068:
1069: public String getQualifiedTypeDefName() {
1070: return prefix + ":dateTime";
1071: }
1072:
1073: public String getQualifiedTypeRefName() {
1074: return prefix + ":dateTime";
1075: }
1076:
1077: public String getQualifiedTypeDefName(String prefix) {
1078: if (prefix != null) {
1079: return prefix + ":dateTime";
1080: }
1081:
1082: if (this .prefix != null) {
1083: return this .prefix + ":dateTime";
1084: }
1085:
1086: return null;
1087: }
1088:
1089: public String getQualifiedTypeRefName(String prefix) {
1090: if (prefix != null) {
1091: return prefix + ":dateTime";
1092: }
1093:
1094: if (this .prefix != null) {
1095: return this .prefix + ":dateTime";
1096: }
1097:
1098: return null;
1099: }
1100:
1101: public Class getJavaClass() {
1102: return Date.class;
1103: }
1104:
1105: public boolean isAbstract() {
1106: return false;
1107: }
1108:
1109: public boolean isDefault() {
1110: return true;
1111: }
1112: }
1113:
1114: class DurationElement extends NameSpaceElement {
1115: public DurationElement(String prefix) {
1116: super (prefix);
1117: }
1118:
1119: public String getTypeDefName() {
1120: return "duration";
1121: }
1122:
1123: public String getTypeRefName() {
1124: return "duration";
1125: }
1126:
1127: public String getQualifiedTypeDefName() {
1128: return prefix + ":duration";
1129: }
1130:
1131: public String getQualifiedTypeRefName() {
1132: return prefix + ":duration";
1133: }
1134:
1135: public String getQualifiedTypeDefName(String prefix) {
1136: if (prefix != null) {
1137: return prefix + ":duration";
1138: }
1139:
1140: if (this .prefix != null) {
1141: return this .prefix + ":duration";
1142: }
1143:
1144: return null;
1145: }
1146:
1147: public String getQualifiedTypeRefName(String prefix) {
1148: if (prefix != null) {
1149: return prefix + ":duration";
1150: }
1151:
1152: if (this .prefix != null) {
1153: return this .prefix + ":duration";
1154: }
1155:
1156: return null;
1157: }
1158:
1159: public Class getJavaClass() {
1160: return Long.class;
1161: }
1162:
1163: public boolean isAbstract() {
1164: return false;
1165: }
1166: }
1167:
1168: class GDayElement extends NameSpaceElement {
1169: public GDayElement(String prefix) {
1170: super (prefix);
1171: }
1172:
1173: public String getTypeDefName() {
1174: return "gDay";
1175: }
1176:
1177: public String getTypeRefName() {
1178: return "gDay";
1179: }
1180:
1181: public String getQualifiedTypeDefName() {
1182: return prefix + ":gDay";
1183: }
1184:
1185: public String getQualifiedTypeRefName() {
1186: return prefix + ":gDay";
1187: }
1188:
1189: public String getQualifiedTypeDefName(String prefix) {
1190: if (prefix != null) {
1191: return prefix + ":gDay";
1192: }
1193:
1194: if (this .prefix != null) {
1195: return this .prefix + ":gDay";
1196: }
1197:
1198: return null;
1199: }
1200:
1201: public String getQualifiedTypeRefName(String prefix) {
1202: if (prefix != null) {
1203: return prefix + ":gDay";
1204: }
1205:
1206: if (this .prefix != null) {
1207: return this .prefix + ":gDay";
1208: }
1209:
1210: return null;
1211: }
1212:
1213: public Class getJavaClass() {
1214: return Date.class;
1215: }
1216:
1217: public boolean isAbstract() {
1218: return false;
1219: }
1220: }
1221:
1222: class GMonthElement extends NameSpaceElement {
1223: public GMonthElement(String prefix) {
1224: super (prefix);
1225: }
1226:
1227: public String getTypeDefName() {
1228: return "gMonth";
1229: }
1230:
1231: public String getTypeRefName() {
1232: return "gMonth";
1233: }
1234:
1235: public String getQualifiedTypeDefName() {
1236: return prefix + ":gMonth";
1237: }
1238:
1239: public String getQualifiedTypeRefName() {
1240: return prefix + ":gMonth";
1241: }
1242:
1243: public String getQualifiedTypeDefName(String prefix) {
1244: if (prefix != null) {
1245: return prefix + ":gMonth";
1246: }
1247:
1248: if (this .prefix != null) {
1249: return this .prefix + ":gMonth";
1250: }
1251:
1252: return null;
1253: }
1254:
1255: public String getQualifiedTypeRefName(String prefix) {
1256: if (prefix != null) {
1257: return prefix + ":gMonth";
1258: }
1259:
1260: if (this .prefix != null) {
1261: return this .prefix + ":gMonth";
1262: }
1263:
1264: return null;
1265: }
1266:
1267: public Class getJavaClass() {
1268: return Date.class;
1269: }
1270:
1271: public boolean isAbstract() {
1272: return false;
1273: }
1274: }
1275:
1276: class GMonthDayElement extends NameSpaceElement {
1277: public GMonthDayElement(String prefix) {
1278: super (prefix);
1279: }
1280:
1281: public String getTypeDefName() {
1282: return "gMonthDay";
1283: }
1284:
1285: public String getTypeRefName() {
1286: return "gMonthDay";
1287: }
1288:
1289: public String getQualifiedTypeDefName() {
1290: return prefix + ":gMonthDay";
1291: }
1292:
1293: public String getQualifiedTypeRefName() {
1294: return prefix + ":gMonthDay";
1295: }
1296:
1297: public String getQualifiedTypeDefName(String prefix) {
1298: if (prefix != null) {
1299: return prefix + ":gMonthDay";
1300: }
1301:
1302: if (this .prefix != null) {
1303: return this .prefix + ":gMonthDay";
1304: }
1305:
1306: return null;
1307: }
1308:
1309: public String getQualifiedTypeRefName(String prefix) {
1310: if (prefix != null) {
1311: return prefix + ":gMonthDay";
1312: }
1313:
1314: if (this .prefix != null) {
1315: return this .prefix + ":gMonthDay";
1316: }
1317:
1318: return null;
1319: }
1320:
1321: public Class getJavaClass() {
1322: return Date.class;
1323: }
1324:
1325: public boolean isAbstract() {
1326: return false;
1327: }
1328: }
1329:
1330: class GYearElement extends NameSpaceElement {
1331: public GYearElement(String prefix) {
1332: super (prefix);
1333: }
1334:
1335: public String getTypeDefName() {
1336: return "gYear";
1337: }
1338:
1339: public String getTypeRefName() {
1340: return "gYear";
1341: }
1342:
1343: public String getQualifiedTypeDefName() {
1344: return prefix + ":gYear";
1345: }
1346:
1347: public String getQualifiedTypeRefName() {
1348: return prefix + ":gYear";
1349: }
1350:
1351: public String getQualifiedTypeDefName(String prefix) {
1352: if (prefix != null) {
1353: return prefix + ":gYear";
1354: }
1355:
1356: if (this .prefix != null) {
1357: return this .prefix + ":gYear";
1358: }
1359:
1360: return null;
1361: }
1362:
1363: public String getQualifiedTypeRefName(String prefix) {
1364: if (prefix != null) {
1365: return prefix + ":gYear";
1366: }
1367:
1368: if (this .prefix != null) {
1369: return this .prefix + ":gYear";
1370: }
1371:
1372: return null;
1373: }
1374:
1375: public Class getJavaClass() {
1376: return Date.class;
1377: }
1378:
1379: public boolean isAbstract() {
1380: return false;
1381: }
1382: }
1383:
1384: class GYearMonthElement extends NameSpaceElement {
1385: public GYearMonthElement(String prefix) {
1386: super (prefix);
1387: }
1388:
1389: public String getTypeDefName() {
1390: return "gYearMonth";
1391: }
1392:
1393: public String getTypeRefName() {
1394: return "gYearMonth";
1395: }
1396:
1397: public String getQualifiedTypeDefName() {
1398: return prefix + ":gYearMonth";
1399: }
1400:
1401: public String getQualifiedTypeRefName() {
1402: return prefix + ":gYearMonth";
1403: }
1404:
1405: public String getQualifiedTypeDefName(String prefix) {
1406: if (prefix != null) {
1407: return prefix + ":gYearMonth";
1408: }
1409:
1410: if (this .prefix != null) {
1411: return this .prefix + ":gYearMonth";
1412: }
1413:
1414: return null;
1415: }
1416:
1417: public String getQualifiedTypeRefName(String prefix) {
1418: if (prefix != null) {
1419: return prefix + ":gYearMonth";
1420: }
1421:
1422: if (this .prefix != null) {
1423: return this .prefix + ":gYearMonth";
1424: }
1425:
1426: return null;
1427: }
1428:
1429: public Class getJavaClass() {
1430: return Date.class;
1431: }
1432:
1433: public boolean isAbstract() {
1434: return false;
1435: }
1436: }
1437:
1438: class TimeElement extends NameSpaceElement {
1439: public TimeElement(String prefix) {
1440: super (prefix);
1441: }
1442:
1443: public String getTypeDefName() {
1444: return "time";
1445: }
1446:
1447: public String getTypeRefName() {
1448: return "time";
1449: }
1450:
1451: public String getQualifiedTypeDefName() {
1452: return prefix + ":time";
1453: }
1454:
1455: public String getQualifiedTypeRefName() {
1456: return prefix + ":time";
1457: }
1458:
1459: public String getQualifiedTypeDefName(String prefix) {
1460: if (prefix != null) {
1461: return prefix + ":time";
1462: }
1463:
1464: if (this .prefix != null) {
1465: return this .prefix + ":time";
1466: }
1467:
1468: return null;
1469: }
1470:
1471: public String getQualifiedTypeRefName(String prefix) {
1472: if (prefix != null) {
1473: return prefix + ":time";
1474: }
1475:
1476: if (this .prefix != null) {
1477: return this .prefix + ":time";
1478: }
1479:
1480: return null;
1481: }
1482:
1483: public Class getJavaClass() {
1484: return Date.class;
1485: }
1486:
1487: public boolean isAbstract() {
1488: return false;
1489: }
1490: }
1491:
1492: class IDElement extends NameSpaceElement {
1493: public IDElement(String prefix) {
1494: super (prefix);
1495: }
1496:
1497: public String getTypeDefName() {
1498: return "ID";
1499: }
1500:
1501: public String getTypeRefName() {
1502: return "ID";
1503: }
1504:
1505: public String getQualifiedTypeDefName() {
1506: return prefix + ":ID";
1507: }
1508:
1509: public String getQualifiedTypeRefName() {
1510: return prefix + ":ID";
1511: }
1512:
1513: public String getQualifiedTypeDefName(String prefix) {
1514: if (prefix != null) {
1515: return prefix + ":ID";
1516: }
1517:
1518: if (this .prefix != null) {
1519: return this .prefix + ":ID";
1520: }
1521:
1522: return null;
1523: }
1524:
1525: public String getQualifiedTypeRefName(String prefix) {
1526: if (prefix != null) {
1527: return prefix + ":ID";
1528: }
1529:
1530: if (this .prefix != null) {
1531: return this .prefix + ":ID";
1532: }
1533:
1534: return null;
1535: }
1536:
1537: public Class getJavaClass() {
1538: return Object.class;
1539: }
1540:
1541: public boolean isAbstract() {
1542: return false;
1543: }
1544: }
1545:
1546: class IDREFElement extends NameSpaceElement {
1547: public IDREFElement(String prefix) {
1548: super (prefix);
1549: }
1550:
1551: public String getTypeDefName() {
1552: return "IDREF";
1553: }
1554:
1555: public String getTypeRefName() {
1556: return "IDREF";
1557: }
1558:
1559: public String getQualifiedTypeDefName() {
1560: return prefix + ":IDREF";
1561: }
1562:
1563: public String getQualifiedTypeRefName() {
1564: return prefix + ":IDREF";
1565: }
1566:
1567: public String getQualifiedTypeDefName(String prefix) {
1568: if (prefix != null) {
1569: return prefix + ":IDREF";
1570: }
1571:
1572: if (this .prefix != null) {
1573: return this .prefix + ":IDREF";
1574: }
1575:
1576: return null;
1577: }
1578:
1579: public String getQualifiedTypeRefName(String prefix) {
1580: if (prefix != null) {
1581: return prefix + ":IDREF";
1582: }
1583:
1584: if (this .prefix != null) {
1585: return this .prefix + ":IDREF";
1586: }
1587:
1588: return null;
1589: }
1590:
1591: public Class getJavaClass() {
1592: return Object.class;
1593: }
1594:
1595: public boolean isAbstract() {
1596: return false;
1597: }
1598: }
1599:
1600: class IDREFSElement extends NameSpaceElement {
1601: public IDREFSElement(String prefix) {
1602: super (prefix);
1603: }
1604:
1605: public String getTypeDefName() {
1606: return "IDREFS";
1607: }
1608:
1609: public String getTypeRefName() {
1610: return "IDREFS";
1611: }
1612:
1613: public String getQualifiedTypeDefName() {
1614: return prefix + ":IDREFS";
1615: }
1616:
1617: public String getQualifiedTypeRefName() {
1618: return prefix + ":IDREFS";
1619: }
1620:
1621: public String getQualifiedTypeDefName(String prefix) {
1622: if (prefix != null) {
1623: return prefix + ":IDREFS";
1624: }
1625:
1626: if (this .prefix != null) {
1627: return this .prefix + ":IDREFS";
1628: }
1629:
1630: return null;
1631: }
1632:
1633: public String getQualifiedTypeRefName(String prefix) {
1634: if (prefix != null) {
1635: return prefix + ":IDREFS";
1636: }
1637:
1638: if (this .prefix != null) {
1639: return this .prefix + ":IDREFS";
1640: }
1641:
1642: return null;
1643: }
1644:
1645: public Class getJavaClass() {
1646: return Object.class;
1647: }
1648:
1649: public boolean isAbstract() {
1650: return false;
1651: }
1652: }
1653:
1654: class ENTITYElement extends NameSpaceElement {
1655: public ENTITYElement(String prefix) {
1656: super (prefix);
1657: }
1658:
1659: public String getTypeDefName() {
1660: return "ENTITY";
1661: }
1662:
1663: public String getTypeRefName() {
1664: return "ENTITY";
1665: }
1666:
1667: public String getQualifiedTypeDefName() {
1668: return prefix + ":ENTITY";
1669: }
1670:
1671: public String getQualifiedTypeRefName() {
1672: return prefix + ":ENTITY";
1673: }
1674:
1675: public String getQualifiedTypeDefName(String prefix) {
1676: if (prefix != null) {
1677: return prefix + ":ENTITY";
1678: }
1679:
1680: if (this .prefix != null) {
1681: return this .prefix + ":ENTITY";
1682: }
1683:
1684: return null;
1685: }
1686:
1687: public String getQualifiedTypeRefName(String prefix) {
1688: if (prefix != null) {
1689: return prefix + ":ENTITY";
1690: }
1691:
1692: if (this .prefix != null) {
1693: return this .prefix + ":ENTITY";
1694: }
1695:
1696: return null;
1697: }
1698:
1699: public Class getJavaClass() {
1700: return Object.class;
1701: }
1702:
1703: public boolean isAbstract() {
1704: return false;
1705: }
1706: }
1707:
1708: class ENTITIESElement extends NameSpaceElement {
1709: public ENTITIESElement(String prefix) {
1710: super (prefix);
1711: }
1712:
1713: public String getTypeDefName() {
1714: return "ENTITIES";
1715: }
1716:
1717: public String getTypeRefName() {
1718: return "ENTITIES";
1719: }
1720:
1721: public String getQualifiedTypeDefName() {
1722: return prefix + ":ENTITIES";
1723: }
1724:
1725: public String getQualifiedTypeRefName() {
1726: return prefix + ":ENTITIES";
1727: }
1728:
1729: public String getQualifiedTypeDefName(String prefix) {
1730: if (prefix != null) {
1731: return prefix + ":ENTITIES";
1732: }
1733:
1734: if (this .prefix != null) {
1735: return this .prefix + ":ENTITIES";
1736: }
1737:
1738: return null;
1739: }
1740:
1741: public String getQualifiedTypeRefName(String prefix) {
1742: if (prefix != null) {
1743: return prefix + ":ENTITIES";
1744: }
1745:
1746: if (this .prefix != null) {
1747: return this .prefix + ":ENTITIES";
1748: }
1749:
1750: return null;
1751: }
1752:
1753: public Class getJavaClass() {
1754: return Object.class;
1755: }
1756:
1757: public boolean isAbstract() {
1758: return false;
1759: }
1760: }
1761:
1762: class NMTOKENElement extends NameSpaceElement {
1763: public NMTOKENElement(String prefix) {
1764: super (prefix);
1765: }
1766:
1767: public String getTypeDefName() {
1768: return "NMTOKEN";
1769: }
1770:
1771: public String getTypeRefName() {
1772: return "NMTOKEN";
1773: }
1774:
1775: public String getQualifiedTypeDefName() {
1776: return prefix + ":NMTOKEN";
1777: }
1778:
1779: public String getQualifiedTypeRefName() {
1780: return prefix + ":NMTOKEN";
1781: }
1782:
1783: public String getQualifiedTypeDefName(String prefix) {
1784: if (prefix != null) {
1785: return prefix + ":NMTOKEN";
1786: }
1787:
1788: if (this .prefix != null) {
1789: return this .prefix + ":NMTOKEN";
1790: }
1791:
1792: return null;
1793: }
1794:
1795: public String getQualifiedTypeRefName(String prefix) {
1796: if (prefix != null) {
1797: return prefix + ":NMTOKEN";
1798: }
1799:
1800: if (this .prefix != null) {
1801: return this .prefix + ":NMTOKEN";
1802: }
1803:
1804: return null;
1805: }
1806:
1807: public Class getJavaClass() {
1808: return Object.class;
1809: }
1810:
1811: public boolean isAbstract() {
1812: return false;
1813: }
1814: }
1815:
1816: class NMTOKENSElement extends NameSpaceElement {
1817: public NMTOKENSElement(String prefix) {
1818: super (prefix);
1819: }
1820:
1821: public String getTypeDefName() {
1822: return "NMTOKENS";
1823: }
1824:
1825: public String getTypeRefName() {
1826: return "NMTOKENS";
1827: }
1828:
1829: public String getQualifiedTypeDefName() {
1830: return prefix + ":NMTOKENS";
1831: }
1832:
1833: public String getQualifiedTypeRefName() {
1834: return prefix + ":NMTOKENS";
1835: }
1836:
1837: public String getQualifiedTypeDefName(String prefix) {
1838: if (prefix != null) {
1839: return prefix + ":NMTOKENS";
1840: }
1841:
1842: if (this .prefix != null) {
1843: return this .prefix + ":NMTOKENS";
1844: }
1845:
1846: return null;
1847: }
1848:
1849: public String getQualifiedTypeRefName(String prefix) {
1850: if (prefix != null) {
1851: return prefix + ":NMTOKENS";
1852: }
1853:
1854: if (this .prefix != null) {
1855: return this .prefix + ":NMTOKENS";
1856: }
1857:
1858: return null;
1859: }
1860:
1861: public Class getJavaClass() {
1862: return Object.class;
1863: }
1864:
1865: public boolean isAbstract() {
1866: return false;
1867: }
1868: }
1869:
1870: class NOTATIONElement extends NameSpaceElement {
1871: public NOTATIONElement(String prefix) {
1872: super (prefix);
1873: }
1874:
1875: public String getTypeDefName() {
1876: return "NOTATION";
1877: }
1878:
1879: public String getTypeRefName() {
1880: return "NOTATION";
1881: }
1882:
1883: public String getQualifiedTypeDefName() {
1884: return prefix + ":NOTATION";
1885: }
1886:
1887: public String getQualifiedTypeRefName() {
1888: return prefix + ":NOTATION";
1889: }
1890:
1891: public String getQualifiedTypeDefName(String prefix) {
1892: if (prefix != null) {
1893: return prefix + ":NOTATION";
1894: }
1895:
1896: if (this .prefix != null) {
1897: return this .prefix + ":NOTATION";
1898: }
1899:
1900: return null;
1901: }
1902:
1903: public String getQualifiedTypeRefName(String prefix) {
1904: if (prefix != null) {
1905: return prefix + ":NOTATION";
1906: }
1907:
1908: if (this .prefix != null) {
1909: return this .prefix + ":NOTATION";
1910: }
1911:
1912: return null;
1913: }
1914:
1915: public Class getJavaClass() {
1916: return Object.class;
1917: }
1918:
1919: public boolean isAbstract() {
1920: return false;
1921: }
1922: }
1923:
1924: class StringElement extends NameSpaceElement {
1925: public StringElement(String prefix) {
1926: super (prefix);
1927: }
1928:
1929: public String getTypeDefName() {
1930: return "string";
1931: }
1932:
1933: public String getTypeRefName() {
1934: return "string";
1935: }
1936:
1937: public String getQualifiedTypeDefName() {
1938: return prefix + ":string";
1939: }
1940:
1941: public String getQualifiedTypeRefName() {
1942: return prefix + ":string";
1943: }
1944:
1945: public String getQualifiedTypeDefName(String prefix) {
1946: if (prefix != null) {
1947: return prefix + ":string";
1948: }
1949:
1950: if (this .prefix != null) {
1951: return this .prefix + ":string";
1952: }
1953:
1954: return null;
1955: }
1956:
1957: public String getQualifiedTypeRefName(String prefix) {
1958: if (prefix != null) {
1959: return prefix + ":string";
1960: }
1961:
1962: if (this .prefix != null) {
1963: return this .prefix + ":string";
1964: }
1965:
1966: return null;
1967: }
1968:
1969: public Class getJavaClass() {
1970: return String.class;
1971: }
1972:
1973: public boolean isAbstract() {
1974: return false;
1975: }
1976:
1977: public boolean isDefault() {
1978: return true;
1979: }
1980: }
1981:
1982: class NormalizedStringElement extends NameSpaceElement {
1983: public NormalizedStringElement(String prefix) {
1984: super (prefix);
1985: }
1986:
1987: public String getTypeDefName() {
1988: return "normalizedString";
1989: }
1990:
1991: public String getTypeRefName() {
1992: return "normalizedString";
1993: }
1994:
1995: public String getQualifiedTypeDefName() {
1996: return prefix + ":normalizedString";
1997: }
1998:
1999: public String getQualifiedTypeRefName() {
2000: return prefix + ":normalizedString";
2001: }
2002:
2003: public String getQualifiedTypeDefName(String prefix) {
2004: if (prefix != null) {
2005: return prefix + ":normalizedString";
2006: }
2007:
2008: if (this .prefix != null) {
2009: return this .prefix + ":normalizedString";
2010: }
2011:
2012: return null;
2013: }
2014:
2015: public String getQualifiedTypeRefName(String prefix) {
2016: if (prefix != null) {
2017: return prefix + ":normalizedString";
2018: }
2019:
2020: if (this .prefix != null) {
2021: return this .prefix + ":normalizedString";
2022: }
2023:
2024: return null;
2025: }
2026:
2027: public Class getJavaClass() {
2028: return String.class;
2029: }
2030:
2031: public boolean isAbstract() {
2032: return false;
2033: }
2034: }
2035:
2036: class TokenElement extends NameSpaceElement {
2037: public TokenElement(String prefix) {
2038: super (prefix);
2039: }
2040:
2041: public String getTypeDefName() {
2042: return "token";
2043: }
2044:
2045: public String getTypeRefName() {
2046: return "token";
2047: }
2048:
2049: public String getQualifiedTypeDefName() {
2050: return prefix + ":token";
2051: }
2052:
2053: public String getQualifiedTypeRefName() {
2054: return prefix + ":token";
2055: }
2056:
2057: public String getQualifiedTypeDefName(String prefix) {
2058: if (prefix != null) {
2059: return prefix + ":token";
2060: }
2061:
2062: if (this .prefix != null) {
2063: return this .prefix + ":token";
2064: }
2065:
2066: return null;
2067: }
2068:
2069: public String getQualifiedTypeRefName(String prefix) {
2070: if (prefix != null) {
2071: return prefix + ":token";
2072: }
2073:
2074: if (this .prefix != null) {
2075: return this .prefix + ":token";
2076: }
2077:
2078: return null;
2079: }
2080:
2081: public Class getJavaClass() {
2082: return Object.class;
2083: }
2084:
2085: public boolean isAbstract() {
2086: return false;
2087: }
2088: }
2089:
2090: class QNameElement extends NameSpaceElement {
2091: public QNameElement(String prefix) {
2092: super (prefix);
2093: }
2094:
2095: public String getTypeDefName() {
2096: return "QName";
2097: }
2098:
2099: public String getTypeRefName() {
2100: return "QName";
2101: }
2102:
2103: public String getQualifiedTypeDefName() {
2104: return prefix + ":QName";
2105: }
2106:
2107: public String getQualifiedTypeRefName() {
2108: return prefix + ":QName";
2109: }
2110:
2111: public String getQualifiedTypeDefName(String prefix) {
2112: if (prefix != null) {
2113: return prefix + ":QName";
2114: }
2115:
2116: if (this .prefix != null) {
2117: return this .prefix + ":QName";
2118: }
2119:
2120: return null;
2121: }
2122:
2123: public String getQualifiedTypeRefName(String prefix) {
2124: if (prefix != null) {
2125: return prefix + ":QName";
2126: }
2127:
2128: if (this .prefix != null) {
2129: return this .prefix + ":QName";
2130: }
2131:
2132: return null;
2133: }
2134:
2135: public Class getJavaClass() {
2136: return Object.class;
2137: }
2138:
2139: public boolean isAbstract() {
2140: return false;
2141: }
2142: }
2143:
2144: class NameElement extends NameSpaceElement {
2145: public NameElement(String prefix) {
2146: super (prefix);
2147: }
2148:
2149: public String getTypeDefName() {
2150: return "Name";
2151: }
2152:
2153: public String getTypeRefName() {
2154: return "Name";
2155: }
2156:
2157: public String getQualifiedTypeDefName() {
2158: return prefix + ":Name";
2159: }
2160:
2161: public String getQualifiedTypeRefName() {
2162: return prefix + ":Name";
2163: }
2164:
2165: public String getQualifiedTypeDefName(String prefix) {
2166: if (prefix != null) {
2167: return prefix + ":Name";
2168: }
2169:
2170: if (this .prefix != null) {
2171: return this .prefix + ":Name";
2172: }
2173:
2174: return null;
2175: }
2176:
2177: public String getQualifiedTypeRefName(String prefix) {
2178: if (prefix != null) {
2179: return prefix + ":Name";
2180: }
2181:
2182: if (this .prefix != null) {
2183: return this .prefix + ":Name";
2184: }
2185:
2186: return null;
2187: }
2188:
2189: public Class getJavaClass() {
2190: return Object.class;
2191: }
2192:
2193: public boolean isAbstract() {
2194: return false;
2195: }
2196: }
2197:
2198: class NCNameElement extends NameSpaceElement {
2199: public NCNameElement(String prefix) {
2200: super (prefix);
2201: }
2202:
2203: public String getTypeDefName() {
2204: return "NCName";
2205: }
2206:
2207: public String getTypeRefName() {
2208: return "NCName";
2209: }
2210:
2211: public String getQualifiedTypeDefName() {
2212: return prefix + ":NCName";
2213: }
2214:
2215: public String getQualifiedTypeRefName() {
2216: return prefix + ":NCName";
2217: }
2218:
2219: public String getQualifiedTypeDefName(String prefix) {
2220: if (prefix != null) {
2221: return prefix + ":NCName";
2222: }
2223:
2224: if (this .prefix != null) {
2225: return this .prefix + ":NCName";
2226: }
2227:
2228: return null;
2229: }
2230:
2231: public String getQualifiedTypeRefName(String prefix) {
2232: if (prefix != null) {
2233: return prefix + ":NCName";
2234: }
2235:
2236: if (this .prefix != null) {
2237: return this .prefix + ":NCName";
2238: }
2239:
2240: return null;
2241: }
2242:
2243: public Class getJavaClass() {
2244: return Object.class;
2245: }
2246:
2247: public boolean isAbstract() {
2248: return false;
2249: }
2250: }
|