wsdlpull
1.23
|
00001 /* 00002 * wsdlpull - A C++ parser for WSDL (Web services description language) 00003 * Copyright (C) 2005-2007 Vivek Krishna 00004 * 00005 * This library is free software; you can redistribute it and/or 00006 * modify it under the terms of the GNU Library General Public 00007 * License as published by the Free Software Foundation; either 00008 * version 2 of the License, or (at your option) any later version. 00009 * 00010 * This library is distributed in the hope that it will be useful, 00011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00013 * Library General Public License for more details. 00014 * 00015 * You should have received a copy of the GNU Library General Public 00016 * License along with this library; if not, write to the Free 00017 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 00018 * 00019 * 00020 */ 00021 00022 #include "schemaparser/SimpleType.h" 00023 00024 //TODO .Need to add checks for validating the occurence of consecutive facets_ 00025 namespace Schema { 00026 00027 SimpleType::SimpleType(const std::string& ns) 00028 :XSDType(ns), 00029 isList_(false), 00030 isUnion_(false), 00031 uTypes_(0) 00032 { 00033 setContentModel(Schema::Simple); 00034 facetId_.clear(); 00035 00036 validFacets_ = new int[XSD_ANYURI + 1]; 00037 00038 //This table maintains a flag which indicates what facets_ are valid for a simple type 00039 validFacets_[XSD_STRING] = validFacets_[XSD_NMTOKEN] = validFacets_[XSD_NMTOKENS] = 00040 validFacets_[XSD_TOKEN] = 00041 LENGTH | MINLEN | MAXLEN | ENUM | WSP | PATTERN; 00042 validFacets_[XSD_INTEGER] = validFacets_[XSD_INT] = validFacets_[XSD_UINT] = 00043 validFacets_[XSD_BYTE] = validFacets_[XSD_POSINT] = 00044 ENUM | WSP | MAXEX | MINEX | MAXINC | MININC | TOTALDIGITS | FRAC | 00045 PATTERN; 00046 validFacets_[XSD_LONG] = validFacets_[XSD_ULONG] = validFacets_[XSD_DECIMAL] = 00047 validFacets_[XSD_INT]; 00048 validFacets_[XSD_SHORT] = validFacets_[XSD_USHORT] = validFacets_[XSD_INT]; 00049 validFacets_[XSD_FLOAT] = validFacets_[XSD_DOUBLE] = 00050 ENUM | WSP | MAXEX | MINEX | MAXINC | MININC | PATTERN; 00051 validFacets_[XSD_BOOLEAN] = WSP | PATTERN; 00052 validFacets_[XSD_TIME] = validFacets_[XSD_DATETIME] = validFacets_[XSD_DATE] = 00053 ENUM | WSP | MAXEX | MINEX | MAXINC | MININC | PATTERN; 00054 validFacets_[XSD_QNAME] = validFacets_[XSD_NCNAME] = validFacets_[XSD_ANYURI] = 00055 LENGTH | MINLEN | MAXLEN | ENUM | WSP | PATTERN; 00056 validFacets_[XSD_ANY] = validFacets_[XSD_ANYTYPE] = NONE | PATTERN; 00057 validFacets_[XSD_BASE64BIN] = validFacets_[XSD_STRING]; 00058 00059 //initialize the union??TODO 00060 facetValue_.numEnums = 0; 00061 00062 facets_["length"] = LENGTH; 00063 facets_["minLength"]= MINLEN; 00064 facets_["maxLength"]= MAXLEN; 00065 facets_["enumeration"]= ENUM; 00066 facets_["whiteSpace"]= WSP; 00067 facets_["pattern"]= PATTERN; 00068 facets_["maxInclusive"]= MAXINC; 00069 facets_["maxExclusive"]= MAXEX; 00070 facets_[ "minInclusive"]= MININC; 00071 facets_["minExclusive"]= MINEX; 00072 facets_["totalDigits"]= TOTALDIGITS; 00073 facets_["fractionDigits"]= FRAC; 00074 } 00075 00076 SimpleType::~SimpleType() { 00077 delete[] validFacets_; 00078 } 00079 00080 //This function also sets the facet if valid 00081 bool 00082 SimpleType::isvalidFacet(std::string facet) 00083 { 00084 if (getBaseTypeId() == 0){ 00085 error("isValidFacet:Unknown base type"); 00086 return false; 00087 } 00088 int facetType=facets_[facet]; 00089 if (validFacets_[getBaseTypeId()] | facetType) 00090 return true; 00091 else 00092 return false; 00093 } 00094 00095 00096 //TODO ..need to add checks to see which facets_ can appear together. 00097 void 00098 SimpleType::setFacetValue(std::string facet, 00099 std::string val) 00100 { 00101 int num = -1; 00102 int facetType=facets_[facet]; 00103 switch (facetType) 00104 { 00105 case ENUM: 00106 facetValue_.numEnums++; 00107 enumValues_.push_back(val); 00108 break; 00109 case PATTERN: 00110 facetValue_.pattern = (const char*) val.c_str(); 00111 break; 00112 case WSP: 00113 if (val == "preserve") 00114 facetValue_.wsp = PRESERVE; 00115 00116 else if (val == "collapse") 00117 facetValue_.wsp = COLLAPSE; 00118 00119 else if (val == "replace") 00120 facetValue_.wsp = REPLACE; 00121 00122 else 00123 error("Invalid facet value for whitespace"); 00124 break; 00125 //all other facet values are numbers 00126 default: 00127 num = XmlUtils::parseInt(val); 00128 break; 00129 } 00130 00131 switch (facetType) 00132 { 00133 case MAXEX: 00134 facetValue_.valRange.maxex = num; 00135 break; 00136 case MAXINC: 00137 facetValue_.valRange.maxinc = num; 00138 break; 00139 case MININC: 00140 facetValue_.valRange.mininc = num; 00141 break; 00142 case MINEX: 00143 facetValue_.valRange.minex = num; 00144 break; 00145 case LENGTH: 00146 facetValue_.length = num; 00147 break; 00148 case MINLEN: 00149 facetValue_.lenRange.minlen = num; 00150 break; 00151 case MAXLEN: 00152 facetValue_.lenRange.maxlen = num; 00153 break; 00154 case TOTALDIGITS: 00155 facetValue_.tot = num; 00156 break; 00157 case FRAC: 00158 facetValue_.frac = num; 00159 break; 00160 default: 00161 break; 00162 } 00163 00164 int numFacets_=facetId_.size(); 00165 if(!(numFacets_!=0 && (facetId_[numFacets_ - 1] == ENUM))) 00166 facetId_.push_back(facetType); 00167 //In case of enum the new enum value does not define a new facet 00168 } 00169 00170 00171 bool 00172 SimpleType::isValidInt(int val)const 00173 { 00174 if (!(getBaseTypeId() == Schema::XSD_INT || 00175 getBaseTypeId() == Schema::XSD_INTEGER)) 00176 return false; 00177 int numdigits = 1, tmp = val; 00178 bool valid = true; 00179 while ((tmp = tmp / 10)) 00180 numdigits++; 00181 for (size_t i = 0; i < facetId_.size() && valid; i++) 00182 { 00183 switch (facetId_[i]) 00184 { 00185 case MAXEX: 00186 if (val < facetValue_.valRange.maxex) 00187 valid = true; 00188 else 00189 valid = false; 00190 break; 00191 case MAXINC: 00192 if (val <= facetValue_.valRange.maxinc) 00193 valid = true; 00194 00195 else 00196 valid = false; 00197 break; 00198 case MININC: 00199 if (val >= facetValue_.valRange.mininc) 00200 valid = true; 00201 00202 else 00203 valid = false; 00204 break; 00205 case MINEX: 00206 if (val > facetValue_.valRange.minex) 00207 valid = true; 00208 00209 else 00210 valid = false; 00211 break; 00212 case LENGTH: 00213 if (numdigits == facetValue_.length) 00214 valid = true; 00215 00216 else 00217 valid = false; 00218 break; 00219 case MINLEN: 00220 if (numdigits >= facetValue_.lenRange.minlen) 00221 valid = true; 00222 00223 else 00224 valid = false; 00225 break; 00226 case MAXLEN: 00227 if (numdigits <= facetValue_.lenRange.maxlen) 00228 valid = true; 00229 00230 else 00231 valid = false; 00232 break; 00233 default: 00234 valid = false; 00235 } 00236 } 00237 return valid; 00238 } 00239 00240 00241 bool 00242 SimpleType::isValidFloat(float val)const 00243 { 00244 00245 //TODO 00246 return true; 00247 } 00248 00249 00250 bool 00251 SimpleType::isValidString(std::string val)const 00252 { 00253 int strlen = val.length(); 00254 bool valid = true; 00255 std::list < std::string >::const_iterator pEnums; 00256 for (size_t i = 0; i < facetId_.size(); i++) 00257 { 00258 switch (facetId_[i]) 00259 { 00260 case LENGTH: 00261 if (strlen == facetValue_.length) 00262 valid = true; 00263 00264 else 00265 valid = false; 00266 break; 00267 case MINLEN: 00268 if (strlen >= facetValue_.lenRange.minlen) 00269 valid = true; 00270 00271 else 00272 valid = false; 00273 break; 00274 case MAXLEN: 00275 if (strlen <= facetValue_.lenRange.maxlen) 00276 valid = true; 00277 00278 else 00279 valid = false; 00280 break; 00281 case ENUM: 00282 { 00283 valid=false; 00284 for (pEnums = enumValues_.begin(); 00285 pEnums != enumValues_.end(); 00286 pEnums++){ 00287 00288 if (*pEnums == val) 00289 valid = true; 00290 } 00291 break; 00292 } 00293 case PATTERN: 00294 valid = true; //TODO 00295 break; 00296 default: 00297 valid = true; 00298 } 00299 } 00300 return valid; 00301 } 00302 00303 00304 /*This function returns the facet values of the requested facet type 00305 if the type is restricted by it. 00306 For enum it returns(via val*) a ptr to std::list<std::string>. 00307 For all other facets_ related to length,its returns(via val*) an int pointer 00308 For inclusive and exclusive facets it returns (via val*) ptr to the value 00309 for example 00310 int * minex=0; 00311 simpleType.getFacetValue(SimpleType::MAXINC,minex); 00312 */ 00313 00314 //TODO add cases to return pointers to other facet values 00315 bool 00316 SimpleType::getFacetValue(int facet, void *& val) 00317 { 00318 val = 0; 00319 bool isFacetPresent = false; 00320 for (size_t i = 0; 00321 i < facetId_.size() && !isFacetPresent; 00322 i++) 00323 isFacetPresent = (facetId_[i] == facet); 00324 00325 if (!isFacetPresent) 00326 return false; 00327 switch (facet) 00328 { 00329 case ENUM: 00330 val = (void *) &(enumValues_); 00331 return true; 00332 break; 00333 case MAXINC: 00334 val = &(facetValue_.valRange.maxinc); 00335 return true; 00336 break; 00337 case MAXEX: 00338 val = (void*) &(facetValue_.valRange.maxex); 00339 return true; 00340 break; 00341 case MININC: 00342 val = (void*) &(facetValue_.valRange.mininc); 00343 return true; 00344 break; 00345 case MINEX: 00346 val = (void*) &(facetValue_.valRange.minex); 00347 return true; 00348 break; 00349 case LENGTH: 00350 val = (void*) &(facetValue_.length); 00351 return true; 00352 break; 00353 case MINLEN: 00354 val = (void*) &(facetValue_.lenRange.minlen); 00355 return true; 00356 break; 00357 case MAXLEN: 00358 val = (void*) &(facetValue_.lenRange.minlen); 00359 return true; 00360 break; 00361 case PATTERN: 00362 val = (void*) &(facetValue_.pattern); 00363 return true; 00364 break; 00365 case TOTALDIGITS: 00366 val = (void*) &(facetValue_.tot); 00367 return true; 00368 break; 00369 case FRAC: 00370 00371 default: 00372 val = 0; 00373 return false; 00374 } 00375 } 00376 00377 00378 void SimpleType::error(std::string msg) 00379 { 00380 msg += "SimpleType::error()"; 00381 SchemaParserException spe(msg); 00382 throw spe; 00383 return; 00384 } 00385 }