DataType.java
0001 /*
0002  *  DataType.java
0003  *
0004  *  Niraj Aswani, 09/March/07
0005  *
0006  *  $Id: DataType.html,v 1.0 2007/03/09 16:13:01 niraj Exp $
0007  */
0008 package gate.creole.ontology;
0009 
0010 import gate.util.GateRuntimeException;
0011 
0012 import java.util.HashMap;
0013 import java.util.Locale;
0014 
0015 import javax.xml.datatype.DatatypeConfigurationException;
0016 import javax.xml.datatype.DatatypeFactory;
0017 import javax.xml.datatype.XMLGregorianCalendar;
0018 
0019 /**
0020  * This class provides a list of datatypes, supported by the ontology
0021  * API.
0022  
0023  @author Niraj Aswani
0024  */
0025 public class DataType {
0026   /**
0027    * for each datatype, there exists a XML Schema URI in ontology which
0028    * is used to denote the specific datatype. For example to denote the
0029    * boolean datatype one would have to use
0030    * "http://www.w3.org/2001/XMLSchema#boolean".
0031    
0032    */
0033   // protected OURI xmlSchemaURI;
0034   protected String xmlSchemaURIString;
0035 
0036   static DatatypeFactory datatypeFactory = null;
0037   static {
0038     try {
0039       datatypeFactory = DatatypeFactory.newInstance();
0040     }
0041     catch(DatatypeConfigurationException e) {
0042       throw new GateRuntimeException(
0043               "could not initialize data type factory :\n", e);
0044     }
0045   }
0046 
0047   /**
0048    * Constructor
0049    
0050    @param xmlSchemaURI for each datatype, there exists a XML Schema
0051    *          URI in ontology which is used to denote the specific
0052    *          datatype. For example to denote the boolean datatype one
0053    *          would have to use
0054    *          "http://www.w3.org/2001/XMLSchema#boolean".
0055    */
0056   public DataType(OURI xmlSchemaURI) {
0057     // this.xmlSchemaURI = xmlSchemaURI;
0058     this.xmlSchemaURIString = xmlSchemaURI.toString();
0059   }
0060 
0061   public DataType(String xmlSchemaURIString) {
0062     this.xmlSchemaURIString = xmlSchemaURIString;
0063     // TODO: make checks here, the schema URI really must be one of
0064     // those
0065     // defined in the standard!
0066   }
0067 
0068   public boolean isStringDataType() {
0069     return this.xmlSchemaURIString
0070             .equals("http://www.w3.org/2001/XMLSchema#string");
0071   }
0072 
0073   /**
0074    * denotes the "http://www.w3.org/2001/XMLSchema#boolean" datatype.
0075    */
0076   public static DataType getBooleanDataType() {
0077     try {
0078       return new BooleanDT("http://www.w3.org/2001/XMLSchema#boolean");
0079     }
0080     catch(InvalidURIException iue) {
0081       return null;
0082     }
0083   }
0084 
0085   /**
0086    * denotes the "http://www.w3.org/2001/XMLSchema#byte" datatype.
0087    */
0088   public static DataType getByteDataType() {
0089     try {
0090       return new ByteDT("http://www.w3.org/2001/XMLSchema#byte");
0091     }
0092     catch(InvalidURIException iue) {
0093       return null;
0094     }
0095   }
0096 
0097   /**
0098    * denotes the "http://www.w3.org/2001/XMLSchema#date" datatype.
0099    */
0100   public static DataType getDateDataType() {
0101     try {
0102       return new DateDT("http://www.w3.org/2001/XMLSchema#date");
0103     }
0104     catch(InvalidURIException iue) {
0105       return null;
0106     }
0107   }
0108 
0109   /**
0110    * denotes the "http://www.w3.org/2001/XMLSchema#decimal" datatype.
0111    */
0112   public static DataType getDecimalDataType() {
0113     try {
0114       return new DoubleDT("http://www.w3.org/2001/XMLSchema#decimal");
0115     }
0116     catch(InvalidURIException iue) {
0117       return null;
0118     }
0119   }
0120 
0121   /**
0122    * denotes the "http://www.w3.org/2001/XMLSchema#double" datatype.
0123    */
0124   public static DataType getDoubleDataType() {
0125     try {
0126       return new DoubleDT("http://www.w3.org/2001/XMLSchema#double");
0127     }
0128     catch(InvalidURIException iue) {
0129       return null;
0130     }
0131   }
0132 
0133   /**
0134    * denotes the "http://www.w3.org/2001/XMLSchema#duration" datatype.
0135    */
0136   public static DataType getDurationDataType() {
0137     try {
0138       return new LongDT("http://www.w3.org/2001/XMLSchema#duration");
0139     }
0140     catch(InvalidURIException iue) {
0141       return null;
0142     }
0143   }
0144 
0145   /**
0146    * denotes the "http://www.w3.org/2001/XMLSchema#float" datatype.
0147    */
0148   public static DataType getFloatDataType() {
0149     try {
0150       return new FloatDT("http://www.w3.org/2001/XMLSchema#float");
0151     }
0152     catch(InvalidURIException iue) {
0153       return null;
0154     }
0155   }
0156 
0157   /**
0158    * denotes the "http://www.w3.org/2001/XMLSchema#int" datatype.
0159    */
0160   public static DataType getIntDataType() {
0161     try {
0162       return new IntegerDT("http://www.w3.org/2001/XMLSchema#int");
0163     }
0164     catch(InvalidURIException iue) {
0165       return null;
0166     }
0167   }
0168 
0169   /**
0170    * denotes the "http://www.w3.org/2001/XMLSchema#integer" datatype.
0171    */
0172   public static DataType getIntegerDataType() {
0173     try {
0174       return new IntegerDT("http://www.w3.org/2001/XMLSchema#integer");
0175     }
0176     catch(InvalidURIException iue) {
0177       return null;
0178     }
0179   }
0180 
0181   /**
0182    * denotes the "http://www.w3.org/2001/XMLSchema#long" datatype.
0183    */
0184   public static DataType getLongDataType() {
0185     try {
0186       return new LongDT("http://www.w3.org/2001/XMLSchema#long");
0187     }
0188     catch(InvalidURIException iue) {
0189       return null;
0190     }
0191   }
0192 
0193   /**
0194    * denotes the "http://www.w3.org/2001/XMLSchema#negativeInteger"
0195    * datatype.
0196    */
0197   public static DataType getNegativeIntegerDataType() {
0198     try {
0199       return new NegativeIntegerDT(
0200               "http://www.w3.org/2001/XMLSchema#negativeInteger");
0201     }
0202     catch(InvalidURIException iue) {
0203       return null;
0204     }
0205   }
0206 
0207   /**
0208    * denotes the "http://www.w3.org/2001/XMLSchema#nonNegativeInteger"
0209    * datatype.
0210    */
0211   public static DataType getNonNegativeIntegerDataType() {
0212     try {
0213       return new NonNegativeIntegerDT(
0214               "http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
0215     }
0216     catch(InvalidURIException iue) {
0217       return null;
0218     }
0219   }
0220 
0221   /**
0222    * denotes the "http://www.w3.org/2001/XMLSchema#nonPositiveInteger"
0223    * datatype.
0224    */
0225   public static DataType getNonPositiveIntegerDataType() {
0226     try {
0227       return new NegativeIntegerDT(
0228               "http://www.w3.org/2001/XMLSchema#nonPositiveInteger");
0229     }
0230     catch(InvalidURIException iue) {
0231       return null;
0232     }
0233   }
0234 
0235   /**
0236    * denotes the "http://www.w3.org/2001/XMLSchema#positiveInteger"
0237    * datatype.
0238    */
0239   public static DataType getPositiveIntegerDataType() {
0240     try {
0241       return new NonNegativeIntegerDT(
0242               "http://www.w3.org/2001/XMLSchema#positiveInteger");
0243     }
0244     catch(InvalidURIException iue) {
0245       return null;
0246     }
0247   }
0248 
0249   /**
0250    * denotes the "http://www.w3.org/2001/XMLSchema#short" datatype.
0251    */
0252   public static DataType getShortDataType() {
0253     try {
0254       return new ShortDT("http://www.w3.org/2001/XMLSchema#short");
0255     }
0256     catch(InvalidURIException iue) {
0257       return null;
0258     }
0259   }
0260 
0261   /**
0262    * denotes the "http://www.w3.org/2001/XMLSchema#string" datatype.
0263    */
0264   public static DataType getStringDataType() {
0265     try {
0266       return new DataType("http://www.w3.org/2001/XMLSchema#string");
0267     }
0268     catch(InvalidURIException iue) {
0269       return null;
0270     }
0271   }
0272 
0273   /**
0274    * denotes the "http://www.w3.org/2001/XMLSchema#time" datatype.
0275    */
0276   public static DataType getTimeDataType() {
0277     try {
0278       return new TimeDT("http://www.w3.org/2001/XMLSchema#time");
0279     }
0280     catch(InvalidURIException iue) {
0281       return null;
0282     }
0283   }
0284 
0285   /**
0286    * denotes the "http://www.w3.org/2001/XMLSchema#dateTime" datatype.
0287    */
0288   public static DataType getDateTimeDataType() {
0289     try {
0290       return new DateTimeDT(
0291               "http://www.w3.org/2001/XMLSchema#dateTime");
0292     }
0293     catch(InvalidURIException iue) {
0294       return null;
0295     }
0296   }
0297 
0298   /**
0299    * denotes the "http://www.w3.org/2001/XMLSchema#unsignedByte"
0300    * datatype.
0301    */
0302   public static DataType getUnsignedByteDataType() {
0303     try {
0304       return new UnsignedByteDT(
0305               "http://www.w3.org/2001/XMLSchema#unsignedByte");
0306     }
0307     catch(InvalidURIException iue) {
0308       return null;
0309     }
0310   }
0311 
0312   /**
0313    * denotes the "http://www.w3.org/2001/XMLSchema#unsignedInt"
0314    * datatype.
0315    */
0316   public static DataType getUnsignedIntDataType() {
0317     try {
0318       return new NonNegativeIntegerDT(
0319               "http://www.w3.org/2001/XMLSchema#unsignedInt");
0320     }
0321     catch(InvalidURIException iue) {
0322       return null;
0323     }
0324   }
0325 
0326   /**
0327    * denotes the "http://www.w3.org/2001/XMLSchema#unsignedLong"
0328    * datatype.
0329    */
0330   public static DataType getUnsignedLongDataType() {
0331     try {
0332       return new UnsignedLongDT(
0333               "http://www.w3.org/2001/XMLSchema#unsignedLong");
0334     }
0335     catch(InvalidURIException iue) {
0336       return null;
0337     }
0338   }
0339 
0340   /**
0341    * denotes the "http://www.w3.org/2001/XMLSchema#unsignedShort"
0342    * datatype.
0343    */
0344   public static DataType getUnsignedShortDataType() {
0345     try {
0346       return new UnsignedShortDT(
0347               "http://www.w3.org/2001/XMLSchema#unsignedShort");
0348     }
0349     catch(InvalidURIException iue) {
0350       return null;
0351     }
0352   }
0353 
0354   @Deprecated
0355   public OURI getXmlSchemaURI() {
0356     return new URI(xmlSchemaURIString, false);
0357   }
0358 
0359   public String getXmlSchemaURIString() {
0360     return xmlSchemaURIString;
0361   }
0362 
0363   /**
0364    * Compares if the two objects are same, i.e. if their string
0365    * representations are identical.
0366    */
0367   @Override
0368   public boolean equals(Object o) {
0369     if(instanceof DataType) {
0370       DataType dt = (DataType)o;
0371       // return
0372       // this.xmlSchemaURI.getNameSpace().equals(dt.xmlSchemaURI.getNameSpace())
0373       // &&
0374       // this.xmlSchemaURI.getResourceName().equals(dt.xmlSchemaURI.getResourceName());
0375       return this.getXmlSchemaURIString().equals(dt.getXmlSchemaURIString());
0376     }
0377     return false;
0378   }
0379   
0380   @Override
0381   public int hashCode() {
0382     return getXmlSchemaURIString().hashCode();
0383   }
0384 
0385   /**
0386    * Checks whether the provided value is a valid value for the datatype
0387    * (e.g. if the datatype is integer, parsing a string value into
0388    * integer causes the exception or not.
0389    
0390    @param value
0391    @return true, if the provided value can be parsed correctly into
0392    *         the datatype, otherwise - false.
0393    */
0394   public boolean isValidValue(String value) {
0395     return true;
0396   }
0397 
0398   /**
0399    * Map containing uri and respective instance of datatypes
0400    */
0401   private static HashMap<String, DataType> datatypeMap = new HashMap<String, DataType>();
0402   static {
0403     datatypeMap.put("http://www.w3.org/2001/XMLSchema#boolean", DataType
0404             .getBooleanDataType());
0405     datatypeMap.put("http://www.w3.org/2001/XMLSchema#byte", DataType
0406             .getByteDataType());
0407     datatypeMap.put("http://www.w3.org/2001/XMLSchema#date", DataType
0408             .getDateDataType());
0409     datatypeMap.put("http://www.w3.org/2001/XMLSchema#decimal", DataType
0410             .getDecimalDataType());
0411     datatypeMap.put("http://www.w3.org/2001/XMLSchema#double", DataType
0412             .getDoubleDataType());
0413     datatypeMap.put("http://www.w3.org/2001/XMLSchema#duration", DataType
0414             .getDurationDataType());
0415     datatypeMap.put("http://www.w3.org/2001/XMLSchema#float", DataType
0416             .getFloatDataType());
0417     datatypeMap.put("http://www.w3.org/2001/XMLSchema#int", DataType
0418             .getIntDataType());
0419     datatypeMap.put("http://www.w3.org/2001/XMLSchema#integer", DataType
0420             .getIntegerDataType());
0421     datatypeMap.put("http://www.w3.org/2001/XMLSchema#long", DataType
0422             .getLongDataType());
0423     datatypeMap.put("http://www.w3.org/2001/XMLSchema#negativeInteger",
0424             DataType.getNegativeIntegerDataType());
0425     datatypeMap.put("http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
0426             DataType.getNonNegativeIntegerDataType());
0427     datatypeMap.put("http://www.w3.org/2001/XMLSchema#nonPositiveInteger",
0428             DataType.getNonPositiveIntegerDataType());
0429     datatypeMap.put("http://www.w3.org/2001/XMLSchema#positiveInteger",
0430             DataType.getPositiveIntegerDataType());
0431     datatypeMap.put("http://www.w3.org/2001/XMLSchema#short", DataType
0432             .getShortDataType());
0433     datatypeMap.put("http://www.w3.org/2001/XMLSchema#string", DataType
0434             .getStringDataType());
0435     datatypeMap.put("http://www.w3.org/2001/XMLSchema#time", DataType
0436             .getTimeDataType());
0437     datatypeMap.put("http://www.w3.org/2001/XMLSchema#unsignedByte", DataType
0438             .getUnsignedByteDataType());
0439     datatypeMap.put("http://www.w3.org/2001/XMLSchema#unsignedInt", DataType
0440             .getUnsignedIntDataType());
0441     datatypeMap.put("http://www.w3.org/2001/XMLSchema#unsignedLong", DataType
0442             .getUnsignedLongDataType());
0443     datatypeMap.put("http://www.w3.org/2001/XMLSchema#unsignedShort", DataType
0444             .getUnsignedShortDataType());
0445     datatypeMap.put("http://www.w3.org/2001/XMLSchema#dateTime", DataType
0446             .getDateTimeDataType());
0447 
0448   }
0449 
0450   /**
0451    * Map containing language codes and their respective locales
0452    */
0453   private static HashMap<String, Locale> localsMap = new HashMap<String, Locale>();
0454   static {
0455     localsMap.put("aa", OConstants.AFAR);
0456     localsMap.put("ab", OConstants.ABKHAZIAN);
0457     localsMap.put("af", OConstants.AFRIKAANS);
0458     localsMap.put("am", OConstants.AMHARIC);
0459     localsMap.put("ar", OConstants.ARABIC);
0460     localsMap.put("as", OConstants.ASSAMESE);
0461     localsMap.put("ay", OConstants.AYMARA);
0462     localsMap.put("az", OConstants.AZERBAIJANI);
0463     localsMap.put("ba", OConstants.BASHKIR);
0464     localsMap.put("be", OConstants.BYELORUSSIAN);
0465     localsMap.put("bg", OConstants.BULGARIAN);
0466     localsMap.put("bh", OConstants.BIHARI);
0467     localsMap.put("bi", OConstants.BISLAMA);
0468     localsMap.put("bn", OConstants.BENGALI);
0469     localsMap.put("bo", OConstants.TIBETAN);
0470     localsMap.put("br", OConstants.BRETON);
0471     localsMap.put("ca", OConstants.CATALAN);
0472     localsMap.put("co", OConstants.CORSICAN);
0473     localsMap.put("cs", OConstants.CZECH);
0474     localsMap.put("cy", OConstants.WELSH);
0475     localsMap.put("da", OConstants.DANISH);
0476     localsMap.put("de", OConstants.GERMAN);
0477     localsMap.put("dz", OConstants.BHUTANI);
0478     localsMap.put("el", OConstants.GREEK);
0479     localsMap.put("en", OConstants.ENGLISH);
0480     localsMap.put("eo", OConstants.ESPERANTO);
0481     localsMap.put("es", OConstants.SPANISH);
0482     localsMap.put("et", OConstants.ESTONIAN);
0483     localsMap.put("eu", OConstants.BASQUE);
0484     localsMap.put("fa", OConstants.PERSIAN);
0485     localsMap.put("fi", OConstants.FINNISH);
0486     localsMap.put("fj", OConstants.FIJI);
0487     localsMap.put("fo", OConstants.FAROESE);
0488     localsMap.put("fr", OConstants.FRENCH);
0489     localsMap.put("fy", OConstants.FRISIAN);
0490     localsMap.put("ga", OConstants.IRISH);
0491     localsMap.put("gd", OConstants.SCOTS);
0492     localsMap.put("gl", OConstants.GALICIAN);
0493     localsMap.put("gn", OConstants.GUARANI);
0494     localsMap.put("gu", OConstants.GUJARATI);
0495     localsMap.put("ha", OConstants.HAUSA);
0496     localsMap.put("he", OConstants.HEBREW);
0497     localsMap.put("hi", OConstants.HINDI);
0498     localsMap.put("hr", OConstants.CROATIAN);
0499     localsMap.put("hu", OConstants.HUNGARIAN);
0500     localsMap.put("hy", OConstants.ARMENIAN);
0501     localsMap.put("ia", OConstants.INTERLINGUA);
0502     localsMap.put("id", OConstants.INDONESIAN);
0503     localsMap.put("ie", OConstants.INTERLINGUE);
0504     localsMap.put("ik", OConstants.INUPIAK);
0505     localsMap.put("is", OConstants.ICELANDIC);
0506     localsMap.put("it", OConstants.ITALIAN);
0507     localsMap.put("iu", OConstants.INUKTITUT);
0508     localsMap.put("ja", OConstants.JAPANESE);
0509     localsMap.put("jw", OConstants.JAVANESE);
0510     localsMap.put("ka", OConstants.GEORGIAN);
0511     localsMap.put("kk", OConstants.KAZAKH);
0512     localsMap.put("kl", OConstants.GREENLANDIC);
0513     localsMap.put("km", OConstants.CAMBODIAN);
0514     localsMap.put("kn", OConstants.KANNADA);
0515     localsMap.put("ko", OConstants.KOREAN);
0516     localsMap.put("ks", OConstants.KASHMIRI);
0517     localsMap.put("ku", OConstants.KURDISH);
0518     localsMap.put("ky", OConstants.KIRGHIZ);
0519     localsMap.put("la", OConstants.LATIN);
0520     localsMap.put("ln", OConstants.LINGALA);
0521     localsMap.put("lo", OConstants.LAOTHIAN);
0522     localsMap.put("lt", OConstants.LITHUANIAN);
0523     localsMap.put("lv", OConstants.LATVIAN);
0524     localsMap.put("mg", OConstants.MALAGASY);
0525     localsMap.put("mi", OConstants.MAORI);
0526     localsMap.put("mk", OConstants.MACEDONIAN);
0527     localsMap.put("ml", OConstants.MALAYALAM);
0528     localsMap.put("mn", OConstants.MONGOLIAN);
0529     localsMap.put("mo", OConstants.MOLDAVIAN);
0530     localsMap.put("mr", OConstants.MARATHI);
0531     localsMap.put("ms", OConstants.MALAY);
0532     localsMap.put("mt", OConstants.MALTESE);
0533     localsMap.put("my", OConstants.BURMESE);
0534     localsMap.put("na", OConstants.NAURU);
0535     localsMap.put("ne", OConstants.NEPALI);
0536     localsMap.put("nl", OConstants.DUTCH);
0537     localsMap.put("no", OConstants.NORWEGIAN);
0538     localsMap.put("oc", OConstants.OCCITAN);
0539     localsMap.put("om", OConstants.OROMO);
0540     localsMap.put("or", OConstants.ORIYA);
0541     localsMap.put("pa", OConstants.PUNJABI);
0542     localsMap.put("pl", OConstants.POLISH);
0543     localsMap.put("ps", OConstants.PASHTO);
0544     localsMap.put("pt", OConstants.PORTUGUESE);
0545     localsMap.put("qu", OConstants.QUECHUA);
0546     localsMap.put("rm", OConstants.RHAETO_ROMANCE);
0547     localsMap.put("rn", OConstants.KIRUNDI);
0548     localsMap.put("ro", OConstants.ROMANIAN);
0549     localsMap.put("ru", OConstants.RUSSIAN);
0550     localsMap.put("rw", OConstants.KINYARWANDA);
0551     localsMap.put("sa", OConstants.SANSKRIT);
0552     localsMap.put("sd", OConstants.SINDHI);
0553     localsMap.put("sg", OConstants.SANGHO);
0554     localsMap.put("sh", OConstants.SERBO_CROATIAN);
0555     localsMap.put("si", OConstants.SINHALESE);
0556     localsMap.put("sk", OConstants.SLOVAK);
0557     localsMap.put("sl", OConstants.SLOVENIAN);
0558     localsMap.put("sm", OConstants.SAMOAN);
0559     localsMap.put("sn", OConstants.SHONA);
0560     localsMap.put("so", OConstants.SOMALI);
0561     localsMap.put("sq", OConstants.ALBANIAN);
0562     localsMap.put("sr", OConstants.SERBIAN);
0563     localsMap.put("ss", OConstants.SISWATI);
0564     localsMap.put("st", OConstants.SESOTHO);
0565     localsMap.put("su", OConstants.SUNDANESE);
0566     localsMap.put("sv", OConstants.SWEDISH);
0567     localsMap.put("sw", OConstants.SWAHILI);
0568     localsMap.put("ta", OConstants.TAMIL);
0569     localsMap.put("te", OConstants.TELUGU);
0570     localsMap.put("tg", OConstants.TAJIK);
0571     localsMap.put("th", OConstants.THAI);
0572     localsMap.put("ti", OConstants.TIGRINYA);
0573     localsMap.put("tk", OConstants.TURKMEN);
0574     localsMap.put("tl", OConstants.TAGALOG);
0575     localsMap.put("tn", OConstants.SETSWANA);
0576     localsMap.put("to", OConstants.TONGA);
0577     localsMap.put("tr", OConstants.TURKISH);
0578     localsMap.put("ts", OConstants.TSONGA);
0579     localsMap.put("tt", OConstants.TATAR);
0580     localsMap.put("tw", OConstants.TWI);
0581     localsMap.put("ug", OConstants.UIGHUR);
0582     localsMap.put("uk", OConstants.UKRAINIAN);
0583     localsMap.put("ur", OConstants.URDU);
0584     localsMap.put("uz", OConstants.UZBEK);
0585     localsMap.put("vi", OConstants.VIETNAMESE);
0586     localsMap.put("vo", OConstants.VOLAPUK);
0587     localsMap.put("wo", OConstants.WOLOF);
0588     localsMap.put("xh", OConstants.XHOSA);
0589     localsMap.put("yi", OConstants.YIDDISH);
0590     localsMap.put("yo", OConstants.YORUBA);
0591     localsMap.put("za", OConstants.ZHUANG);
0592     localsMap.put("zh", OConstants.CHINESE);
0593     localsMap.put("zu", OConstants.ZULU);
0594   }
0595 
0596   /**
0597    * Gets the respective datatype for the given datatype URI. If the URI
0598    * is invalid, the method returns null.
0599    */
0600   public static DataType getDataType(String datatypeURI) {
0601     return datatypeMap.get(datatypeURI);
0602   }
0603 
0604   /**
0605    * Gets the respective locale for the given 2 character language code.
0606    * If the code doesn't match, the method returns null.
0607    */
0608   public static Locale getLocale(String languageCode) {
0609     if(languageCode == nullreturn null;
0610     return localsMap.get(languageCode.toLowerCase());
0611   }
0612 
0613 }
0614 
0615 /**
0616  * Boolean DataType
0617  
0618  @author niraj
0619  */
0620 class BooleanDT extends DataType {
0621   public BooleanDT(OURI xmlSchemaURI) {
0622     super(xmlSchemaURI);
0623   }
0624   public BooleanDT(String xmlSchemaURIString) {
0625     super(xmlSchemaURIString);
0626   }
0627 
0628   /**
0629    * A Method to validate the boolean value
0630    */
0631   @Override
0632   public boolean isValidValue(String value) {
0633     try {
0634       if((Boolean.parseBoolean(value"").equalsIgnoreCase(value))
0635         return true;
0636       return false;
0637     }
0638     catch(Exception e) {
0639       return false;
0640     }
0641   }
0642 }
0643 
0644 /**
0645  * Byte DataType
0646  
0647  @author niraj
0648  
0649  */
0650 class ByteDT extends DataType {
0651   public ByteDT(OURI xmlSchemaURI) {
0652     super(xmlSchemaURI);
0653   }
0654   public ByteDT(String xmlSchemaURIString) {
0655     super(xmlSchemaURIString);
0656   }
0657 
0658   /**
0659    * Methods check if the value is valid for the datatype
0660    */
0661   @Override
0662   public boolean isValidValue(String value) {
0663     try {
0664       if((Byte.parseByte(value"").equalsIgnoreCase(value)) return true;
0665       ;
0666       return false;
0667     }
0668     catch(Exception e) {
0669       return false;
0670     }
0671   }
0672 }
0673 
0674 /**
0675  * Double Datatype
0676  
0677  @author niraj
0678  
0679  */
0680 class DoubleDT extends DataType {
0681   public DoubleDT(OURI xmlSchemaURI) {
0682     super(xmlSchemaURI);
0683   }
0684   public DoubleDT(String xmlSchemaURIString) {
0685     super(xmlSchemaURIString);
0686   }
0687 
0688   /**
0689    * Methods check if the value is valid for the datatype
0690    */
0691   @Override
0692   public boolean isValidValue(String value) {
0693     try {
0694       Double.parseDouble(value);
0695       return true;
0696     }
0697     catch(Exception e) {
0698       return false;
0699     }
0700   }
0701 }
0702 
0703 class DateDT extends DataType {
0704   public DateDT(OURI xmlSchemaURI) {
0705     super(xmlSchemaURI);
0706   }
0707   public DateDT(String xmlSchemaURIString) {
0708     super(xmlSchemaURIString);
0709   }
0710 
0711   /**
0712    * Methods check if the value is valid for the datatype
0713    */
0714   @Override
0715   public boolean isValidValue(String value) {
0716     try {
0717       XMLGregorianCalendar cal = datatypeFactory.newXMLGregorianCalendar(value);
0718       String schema = cal.getXMLSchemaType().getNamespaceURI() "#"
0719               + cal.getXMLSchemaType().getLocalPart();
0720       return schema.equals(getXmlSchemaURIString());
0721     }
0722     catch(Exception e) {
0723       return false;
0724     }
0725   }
0726 }
0727 
0728 class DateTimeDT extends DataType {
0729   public DateTimeDT(OURI xmlSchemaURI) {
0730     super(xmlSchemaURI);
0731   }
0732   public DateTimeDT(String xmlSchemaURIString) {
0733     super(xmlSchemaURIString);
0734   }
0735 
0736   /**
0737    * Methods check if the value is valid for the datatype
0738    */
0739   @Override
0740   public boolean isValidValue(String value) {
0741     try {
0742       XMLGregorianCalendar cal = datatypeFactory.newXMLGregorianCalendar(value);
0743       String schema = cal.getXMLSchemaType().getNamespaceURI() "#"
0744               + cal.getXMLSchemaType().getLocalPart();
0745       return schema.equals(getXmlSchemaURIString());
0746     }
0747     catch(Exception e) {
0748       e.printStackTrace();
0749       return false;
0750     }
0751   }
0752 }
0753 
0754 class TimeDT extends DataType {
0755   public TimeDT(OURI xmlSchemaURI) {
0756     super(xmlSchemaURI);
0757   }
0758   public TimeDT(String xmlSchemaURIString) {
0759     super(xmlSchemaURIString);
0760   }
0761 
0762   /**
0763    * Methods check if the value is valid for the datatype
0764    */
0765   @Override
0766   public boolean isValidValue(String value) {
0767     try {
0768       XMLGregorianCalendar cal = datatypeFactory.newXMLGregorianCalendar(value);
0769       String schema = cal.getXMLSchemaType().getNamespaceURI() "#"
0770               + cal.getXMLSchemaType().getLocalPart();
0771       return schema.equals(getXmlSchemaURIString());
0772     }
0773     catch(Exception e) {
0774       return false;
0775     }
0776   }
0777 }
0778 
0779 /**
0780  * Long Datatype
0781  
0782  @author niraj
0783  
0784  */
0785 class LongDT extends DataType {
0786   public LongDT(OURI xmlSchemaURI) {
0787     super(xmlSchemaURI);
0788   }
0789   public LongDT(String xmlSchemaURIString) {
0790     super(xmlSchemaURIString);
0791   }
0792 
0793   /**
0794    * Methods check if the value is valid for the datatype
0795    */
0796   @Override
0797   public boolean isValidValue(String value) {
0798     try {
0799       if((Long.parseLong(value"").equalsIgnoreCase(value)) return true;
0800       ;
0801       return false;
0802     }
0803     catch(Exception e) {
0804       return false;
0805     }
0806   }
0807 }
0808 
0809 /**
0810  * Float Datatype
0811  
0812  @author niraj
0813  
0814  */
0815 class FloatDT extends DataType {
0816   public FloatDT(OURI xmlSchemaURI) {
0817     super(xmlSchemaURI);
0818   }
0819   public FloatDT(String xmlSchemaURIString) {
0820     super(xmlSchemaURIString);
0821   }
0822 
0823   /**
0824    * Methods check if the value is valid for the datatype
0825    */
0826   @Override
0827   public boolean isValidValue(String value) {
0828     try {
0829       Float.parseFloat(value);
0830       return true;
0831     }
0832     catch(Exception e) {
0833       return false;
0834     }
0835   }
0836 }
0837 
0838 /**
0839  * Integer Datatype
0840  
0841  @author niraj
0842  
0843  */
0844 class IntegerDT extends DataType {
0845   public IntegerDT(OURI xmlSchemaURI) {
0846     super(xmlSchemaURI);
0847   }
0848   public IntegerDT(String xmlSchemaURIString) {
0849     super(xmlSchemaURIString);
0850   }
0851 
0852   /**
0853    * Methods check if the value is valid for the datatype
0854    */
0855   @Override
0856   public boolean isValidValue(String value) {
0857     try {
0858       if((Integer.parseInt(value"").equalsIgnoreCase(value)) return true;
0859       ;
0860       return false;
0861     }
0862     catch(Exception e) {
0863       return false;
0864     }
0865   }
0866 }
0867 
0868 /**
0869  * Negative Integer Datatype
0870  
0871  @author niraj
0872  
0873  */
0874 class NegativeIntegerDT extends DataType {
0875   public NegativeIntegerDT(OURI xmlSchemaURI) {
0876     super(xmlSchemaURI);
0877   }
0878   public NegativeIntegerDT(String xmlSchemaURIString) {
0879     super(xmlSchemaURIString);
0880   }
0881 
0882   /**
0883    * Methods check if the value is valid for the datatype
0884    */
0885   @Override
0886   public boolean isValidValue(String value) {
0887     try {
0888       int intVal = Integer.parseInt(value);
0889       if(!(intVal + "").equalsIgnoreCase(value)) return false;
0890       return intVal < 0;
0891     }
0892     catch(Exception e) {
0893       return false;
0894     }
0895   }
0896 }
0897 
0898 /**
0899  * NonNegativeInteger Datatype
0900  
0901  @author niraj
0902  
0903  */
0904 class NonNegativeIntegerDT extends DataType {
0905   public NonNegativeIntegerDT(OURI xmlSchemaURI) {
0906     super(xmlSchemaURI);
0907   }
0908   public NonNegativeIntegerDT(String xmlSchemaURIString) {
0909     super(xmlSchemaURIString);
0910   }
0911 
0912   /**
0913    * Methods check if the value is valid for the datatype
0914    */
0915   @Override
0916   public boolean isValidValue(String value) {
0917     try {
0918       int intVal = Integer.parseInt(value);
0919       if(!(intVal + "").equalsIgnoreCase(value)) return false;
0920       return intVal > -1;
0921     }
0922     catch(Exception e) {
0923       return false;
0924     }
0925   }
0926 }
0927 
0928 /**
0929  * Short Datatype
0930  
0931  @author niraj
0932  
0933  */
0934 class ShortDT extends DataType {
0935   public ShortDT(OURI xmlSchemaURI) {
0936     super(xmlSchemaURI);
0937   }
0938   public ShortDT(String xmlSchemaURIString) {
0939     super(xmlSchemaURIString);
0940   }
0941 
0942   /**
0943    * Methods check if the value is valid for the datatype
0944    */
0945   @Override
0946   public boolean isValidValue(String value) {
0947     try {
0948       short intVal = Short.parseShort(value);
0949       if(!(intVal + "").equalsIgnoreCase(value)) return false;
0950       return true;
0951     }
0952     catch(Exception e) {
0953       return false;
0954     }
0955   }
0956 }
0957 
0958 /**
0959  * UnsignedByte Datatype
0960  
0961  @author niraj
0962  
0963  */
0964 class UnsignedByteDT extends DataType {
0965   public UnsignedByteDT(OURI xmlSchemaURI) {
0966     super(xmlSchemaURI);
0967   }
0968   public UnsignedByteDT(String xmlSchemaURIString) {
0969     super(xmlSchemaURIString);
0970   }
0971 
0972   /**
0973    * Methods check if the value is valid for the datatype
0974    */
0975   @Override
0976   public boolean isValidValue(String value) {
0977     try {
0978       byte byteVal = Byte.parseByte(value);
0979       if(!(byteVal + "").equalsIgnoreCase(value)) return false;
0980       return byteVal > -1;
0981     }
0982     catch(Exception e) {
0983       return false;
0984     }
0985   }
0986 }
0987 
0988 /**
0989  * UnsignedLong Datatype
0990  
0991  @author niraj
0992  
0993  */
0994 class UnsignedLongDT extends DataType {
0995   public UnsignedLongDT(OURI xmlSchemaURI) {
0996     super(xmlSchemaURI);
0997   }
0998   public UnsignedLongDT(String xmlSchemaURIString) {
0999     super(xmlSchemaURIString);
1000   }
1001 
1002   /**
1003    * Methods check if the value is valid for the datatype
1004    */
1005   @Override
1006   public boolean isValidValue(String value) {
1007     try {
1008       long longVal = Long.parseLong(value);
1009       if(!(longVal + "").equalsIgnoreCase(value)) return false;
1010       return longVal > -1;
1011     }
1012     catch(Exception e) {
1013       return false;
1014     }
1015   }
1016 }
1017 
1018 /**
1019  * UnsignedShort Datatype
1020  
1021  @author niraj
1022  
1023  */
1024 class UnsignedShortDT extends DataType {
1025   public UnsignedShortDT(OURI xmlSchemaURI) {
1026     super(xmlSchemaURI);
1027   }
1028   public UnsignedShortDT(String xmlSchemaURIString) {
1029     super(xmlSchemaURIString);
1030   }
1031 
1032   /**
1033    * Methods check if the value is valid for the datatype
1034    */
1035   @Override
1036   public boolean isValidValue(String value) {
1037     try {
1038       short shortVal = Short.parseShort(value);
1039       if(!(shortVal + "").equalsIgnoreCase(value)) return false;
1040       return shortVal > -1;
1041     }
1042     catch(Exception e) {
1043       return false;
1044     }
1045   }
1046 
1047 }