38 const std::string & schemaPath)
39 :errorOccured_(false),
47 schemaPath_(schemaPath)
53 const std::string & schemaPath)
54 :errorOccured_(false),
62 schemaPath_(schemaPath)
64 uri_ = Uri.substr(0,Uri.rfind(
'/') + 1);
67 xmlStream.open(wsdlFileName.c_str());
71 std::string e=
"Unable to connect to ";
77WsdlParser::initialize(
bool file)
79 if (schemaPath_.empty()) {
82 schemaPath_= SCHEMADIR;
84 schemaPath_=
"src/schemas";
98 wsdlExtensions_.clear();
99 schemaParser_.clear();
114 schemaParser_.push_back(sParser);
117 soap_ =
new Soap(schemaPath_);
128 for (list < const Message * >::iterator mi =
129 messages_.begin(); mi != messages_.end();
132 for (list < Binding * >::iterator bi =
133 bindings_.begin(); bi != bindings_.end();
137 for (list < Service*>::iterator si =services_.begin();
138 si != services_.end();
142 for (list < PortType * >::iterator pti =
143 porttypes_.begin(); pti != porttypes_.end();
147 for (i = 0; i < schemaParser_.size(); i++)
148 delete schemaParser_[i];
153 for (list < string * >::iterator sti =
154 docs_list_.begin(); sti != docs_list_.end();
158 for (vector<ExtensionInfo>::iterator ie = wsdlExtensions_.begin();
159 ie != wsdlExtensions_.end();
176 error (
"Attempted to extract a Binding when ,no binding was parsed",1);
181 return bindings_.back();
191 wsdlExtensions_.push_back(exi);
205 for (list <Binding * >::iterator pBinding =
206 bindings_.begin(); pBinding != bindings_.end();
219 error (
"Attempted to extract a Service when ,no service was parsed",1);
224 return services_.back();
239 for (list <Service * >::iterator si =services_.begin();
240 si != services_.end();
251 if (services_.size() > 0)
253 from = services_.begin();
254 to = services_.end();
263 error (
"Attempted to extract a PortType when ,no PortType was parsed",1);
268 return porttypes_.back();
284 pPortType != porttypes_.end();
286 if ((*pPortType)->getName() == name)
315 for (
int i = 0; i < num; i++)
331 error (
"Attempted to extract a Message when ,no Message was parsed",1);
336 return messages_.back();
342WsdlParser::pgetMessage(
const Qname & qn)
348 putMessage(newMessage);
364 for (list < const Message * >::iterator pMessage =
365 messages_.begin(); pMessage != messages_.end();
367 if ((*pMessage)->getName() == name)
379 for (
size_t i = 0; i < schemaParser_.size(); i++){
380 if (schemaParser_[i]->
getNamespace() == targetNamespace)
383 if (schemaParser_[i]->isImported(targetNamespace)) {
385 return schemaParser_[i]->getImportedSchemaParser(targetNamespace);
405WsdlParser::peek(
bool lookahead)
409 int event_type, tmp_event_type = xParser_->
getEventType();
410 int tmpState = state_;
416 if (lookahead ==
true || state_ ==
START || state_ ==
NONE)
422 string tag = xParser_->
getName();
427 error(
"Syntax error at the start");
434 else if (tag ==
"definitions")
437 else if (tag ==
"documentation")
440 else if (tag ==
"annotation")
443 else if (tag ==
"import")
446 else if (tag ==
"schema")
449 else if (tag ==
"types")
452 else if (tag ==
"message")
455 else if (tag ==
"port")
458 else if (tag ==
"operation")
461 else if (tag ==
"portType")
464 else if (tag ==
"input")
467 else if (tag ==
"output")
470 else if (tag ==
"fault")
473 else if (tag ==
"part")
476 else if (tag ==
"binding")
479 else if (tag ==
"service")
483 error(
"Unknown Tag " + tag);
486 if (tag ==
"definitions")
495 if (tag ==
"types" ||
497 tag ==
"documentation"||
498 tag ==
"annotation"||
504 return state_ =
NONE;
506 return peek(lookahead);
517 error(
"Doc Declaration ??");
520 error(
"Unknown Wsdl tag");
524 && tmpState == state_ &&event_type ==
587 error(
"Syntax error");
591 catch(WsdlException we)
595 errorOccured_ =
true;
599 ostr << we.description <<
" at " << we.line <<
"," << we.col << std::endl;
606 errorOccured_ =
true;
618WsdlParser::parseDoc()
620 string* documentation =
new string();
622 error(
"syntax error");
628 *documentation += xParser_->
getText();
630 && xParser_->
getName() ==
"documentation")
633 docs_list_.push_back(documentation);
636 return documentation;
644WsdlParser::parseAnnotation()
647 error(
"syntax error");
653 &&xParser_->
getName() ==
"annotation")
665WsdlParser::parseDefinitions()
668 error(
"syntax error");
684 schemaParser_.push_back(sParser);
693 schemaParser_.push_back(sParser);
701 for (
size_t j = 0; j < wsdlExtensions_.size(); j++)
702 if (wsdlExtensions_[j].we != 0 &&
703 wsdlExtensions_[j].we->isNamespaceHandler(xParser_->
getNamespaceUri(i)))
705 wsdlExtensions_[j].we->setNamespacePrefix(xParser_->
709 wsdlExtensions_[j].we->setStartId(MAX_EXT_XML * j + 1);
717 new SchemaParser(wsdlExtensions_[j].we->getExtensibilitySchema(),
718 wsdlExtensions_ [j].we->getNamespace(),ostr,schemaPath_);
721 xtmpSchemaParser->
addImport(schemaParser_[0]);
724 wsdlExtensions_[j].spe = xtmpSchemaParser;
725 wsdlExtensions_[j].we->
726 setSchemaParser(xtmpSchemaParser);
727 wsdlExtensions_[j].we->setWsdlParser(
this);
731 std::string err =
"Error parsing the schema for the namespace ";
732 err +=wsdlExtensions_[j].we->getNamespace();
734 err +=
"Unable to locate the file ";
735 err += wsdlExtensions_[j].we->getExtensibilitySchema();
744 error(
"Atleast a targetNamespace attribute is needed");
745 for (i = 0; i < num_attr; i++)
764WsdlParser::parseImport()
767 error(
"syntax error");
783 wsdlStream.open(fname.c_str());
795 error(
"Error while opening the included wsdl " + imp.loc);
798 error(
"location is a required attribute for <import>");
800 imports_.push_back(imp);
809WsdlParser::parseMessage()
812 error(
"syntax error");
819 m=
new Message(*
this);
824 for (
int i = 0; i < num_att; i++){
827 m->addExtAttribute(handleExtensibilityAttributes
832 if (m->getName() ==
"")
833 error(
"syntax error <message> name required");
839 m->setDocumentation(parseDoc());
847 while (state_ ==
PART)
850 int type_id = 0, schemaId = -1;
855 for (
int i = 0; i < num_att; i++)
869 (
"either type or element must occur(only once) in part ");
881 type_id = getTypeId(type);
883 error(
"Could not resolve type " +
884 type.getNamespace() +
":" +
885 type.getLocalName());
891 e = getElement(type);
893 error(
"Could not resolve element " +
894 type.getNamespace() +
":" +
895 type.getLocalName());
900 schemaId = getSchema(type,reftype ==
Part::Type);
904 p_extId = handleExtensibilityAttributes(xParser_->
913 error(
"Syntax error");
922 m->addPart(p_name, reftype, (
void*)(e) , schemaId);
924 m->addPart(p_name, reftype, (
void*)(&type_id) , schemaId);
925 m->addExtElement(p_extId);
929 catch(WsdlException we)
941 m->addExtElement(handleExtensibilityElement(
MESSAGE));
953WsdlParser::parsePortType()
958 PortType * pt =
new PortType(*
this);
960 for (
int i = 0; i < num_att; i++){
969 pt->addExtAttribute(handleExtensibilityAttributes
975 error(
"Syntax error.Unrecognized attribute");
978 if (pt->getName() ==
"")
979 error(
"syntax error <PortType> name required");
984 pt->setDocumentation(parseDoc());
992 Operation * op = parseOperation(pt);
1000 pt->addExtElement(handleExtensibilityElement(
PORT_TYPE));
1012WsdlParser::parseOperation(PortType * p)
1014 Operation * op =
new Operation(*
this,p);
1016 error(
"syntax error");
1019 for (
int i = 0; i < num_att; i++){
1029 op->addExtAttribute(handleExtensibilityAttributes
1039 error(
"Syntax error..unrecognized attribute");
1041 if (op->getName() ==
"")
1042 error(
"syntax error <operation> name required");
1046 op->setDocumentation(parseDoc());
1049 if (state_ ==
INPUT)
1066 while (state_ ==
FAULT)
1077 else if (state_ ==
OUTPUT)
1084 if (state_ ==
INPUT)
1092 while (state_ ==
FAULT)
1103 op->setDocumentation(parseDoc());
1109 op->addExtElement(handleExtensibilityElement(
OPERATION));
1119WsdlParser::processMessageExtensibility(Operation * op,
1124 std::string message_name;
1125 for (
int i = 0; i < num_att; i++){
1135 op->addMessageExtensibility(mtype,handleExtensibilityAttributes
1143WsdlParser::parseTypes()
1159 for (
size_t s = 1 ;s<schemaParser_.size();s++){
1171 error(
"Error parsing schema types for "+tnsUri_);
1173 schemaParser_.push_back(sParser);
1177 for (
size_t i = 1; i < schemaParser_.size(); i++)
1180 for (
size_t j = 1; j < schemaParser_.size(); j++) {
1182 if (schemaParser_[i]->isImported(schemaParser_[j]->
getNamespace()))
1183 schemaParser_[i]->addImport(schemaParser_[j]);
1187 if (!schemaParser_[i]->finalize())
1188 error(
"Invalid schema");
1197 we.WsdlState = state_;
1204WsdlParser::putMessage(Message * m)
1208 messages_.push_back(m);
1213WsdlParser::putBinding(Binding * bn)
1215 bindings_.push_back(bn);
1219WsdlParser::putPortType(PortType * pt)
1221 porttypes_.push_back(pt);
1226WsdlParser::handleExtensibilityElement(
int parent)
1235 return we->handleElement(parent, xParser_);
1240WsdlParser::handleExtensibilityAttributes(
string prefix,
string name)
1247 return we->handleAttribute(state_, name, xParser_);
1253 for (
size_t i = 0; i < wsdlExtensions_.size(); i++)
1254 if (wsdlExtensions_[i].we != 0 &&
1255 (wsdlExtensions_[i].we->isNamespaceHandler(Ns)))
1256 return wsdlExtensions_[i].we;
1267 for (
size_t i = 0; i < wsdlExtensions_.size(); i++)
1268 if (wsdlExtensions_[i].we != 0 &&
1269 (extId >= wsdlExtensions_[i].we->getStartId()&&
1270 extId < MAX_EXT_XML + wsdlExtensions_[i].we->getStartId()))
1271 return wsdlExtensions_[i].we;
1277WsdlParser::parseBinding()
1282 int opBinding, inputBinding, outputBinding, faultBinding, index,
1284 opBinding = inputBinding = outputBinding = faultBinding = index =
1287 error(
"syntax error");
1292 for (i = 0; i < num_att; i++)
1304 error(
"Unknown port type "+ q.getLocalName());
1306 (
const_cast<PortType*
>(pt))->setBinding(bn);
1310 error(
"Syntax error..unrecognized attribute");
1324 handleExtensibilityElement(
BINDING));
1327 if(bindingExtension)
1335 const Operation *op = NULL;
1336 for (i = 0; i < num_att; i++){
1346 error(
"Unrecognized attribute");
1358 opBinding = handleExtensibilityElement(
OPERATION);
1367 if (state_ ==
INPUT) {
1372 inputBinding = handleExtensibilityElement(
OPERATION);
1382 outputBinding = handleExtensibilityElement(
OPERATION);
1387 while (state_ ==
FAULT) {
1392 faultBinding = handleExtensibilityElement(
OPERATION);
1403WsdlParser::parseService()
1406 error(
"Syntax error");
1408 Service * sv =
new Service(*
this);
1411 for (i = 0; i < num_att; i++) {
1418 error(
"Unrecognized attribute");
1420 sv->setName(serviceName);
1424 sv->setDocumentation(parseDoc());
1426 while (state_ ==
PORT) {
1428 string bnName,portName;
1430 int serviceExtId = 0;
1432 for (i = 0; i < num_att; i++) {
1454 serviceExtId = handleExtensibilityElement(
BINDING);
1458 bn->addServiceExtId(serviceExtId);
1460 sv->addPort(portName,bn,serviceExtId);
1462 services_.push_back(sv);
1471WsdlParser::getSchema(
const Qname & name,
bool isType)
1481 for (
size_t i = 0; i < schemaParser_.size(); i++) {
1489 if ((isType && schemaParser_[i]->getType(name,
false) != 0) ||
1490 (!isType && schemaParser_[i]->getElement(name,
false) != 0))
1495 else if (schemaParser_[i]->isImported(type.
getNamespace())) {
1498 if ((isType && schemaParser_[i]->getType(name) != 0) ||
1499 (!isType && schemaParser_[i]->getElement(name) != 0))
1508WsdlParser::getElement(
const Qname& name)
1510 int i = getSchema(name,
false);
1512 return const_cast<Element*
>(schemaParser_[i]->getElement(name));
1518WsdlParser::getTypeId(
const Qname & type)
1521 int i = getSchema(type,
true);
1525 return schemaParser_[i]->getTypeId(t);
1533 std::vector<SchemaParser* >::iterator & to)
1536 from=schemaParser_.begin();
1539 to=schemaParser_.end();
1544WsdlParser::error(
string s,
int level)
1554 we.WsdlState = state_;
1555 errorOccured_ =
true;
1559 else if (level == 1) {
1561 ostr<<
"Wsdl parser warning : "<<s<<endl;
1563 else if (level == 2) {
1565 ostr<<
"Wsdl parser info : "<<s<<endl;
1574 if(bindings_.size()>0){
1576 begin=bindings_.begin();
1577 end=bindings_.end();
1588 if(porttypes_.size()>0){
1590 begin=porttypes_.begin();
1591 end=porttypes_.end();
1601 return schemaParser_.size() - 2;
1608 schemaPath_ = schemaPath;
1610 for (vector<ExtensionInfo>::iterator ie = wsdlExtensions_.begin();
1611 ie != wsdlExtensions_.end();
1613 ie->we->setSchemaPath(schemaPath);
#define FEATURE_PROCESS_NAMESPACES
std::string getLocalName(void) const
void setNamespace(std::string uri)
std::string getPrefix(void) const
std::string getNamespace(void) const
std::string getNamespace(void) const
void setUri(const std::string &u)
bool addImport(std::string ns, std::string location="")
void addOpBinding(int index, int oBn)
void setPortType(const PortType *pt)
void addOutputBinding(int index, int opBn)
void addFaultBinding(int index, int fBn)
void setBindingMethod(const std::string &ns)
void addInputBinding(int index, int ipBn)
std::list< Binding * >::const_iterator cBindingIterator
void setBindingInfo(int id)
int addOperation(const Operation *op)
std::vector< Operation * >::const_iterator cOpIterator
const Operation * getOperation(int index) const
std::list< PortType * >::const_iterator cPortTypeIterator
bool getOperations(Operation::cOpIterator &start, Operation::cOpIterator &finish) const
int getNumOps(void) const
std::string getEncodingUri(void) const
std::string getEncodingSchema(void) const
void setDocumentation(std::string *s)
void setName(std::string nam)
std::string getName() const
virtual std::string getNamespace() const =0
const PortType * getPortType()
const Service * getService()
WsdlExtension * getExtensibilityHandler(const std::string &ns)
int getNumSchemas() const
static bool useLocalSchema_
void getSchemaParsers(std::vector< SchemaParser * >::iterator &from, std::vector< SchemaParser * >::iterator &to)
void addExtensibilityHandler(WsdlExtension *ext)
std::list< Service * >::iterator ServiceIterator
std::string getNamespace(void)
const SchemaParser * getSchemaParser(std::string targetNamespace) const
void getServices(ServiceIterator &from, ServiceIterator &to)
bool getBindings(Binding::cBindingIterator &begin, Binding::cBindingIterator &end) const
const Binding * getBinding()
WsdlParser(std::istream &in=std::cin, std::ostream &out=std::cout, const std::string &schemaPath="")
bool getPortTypes(PortType::cPortTypeIterator &begin, PortType::cPortTypeIterator &end) const
const Message * getMessage()
bool getOperations(const Qname &portType, Operation::cOpIterator &begin, Operation::cOpIterator &end)
const Operation * getOperation(const Qname &portType, const Qname &q)
void setSchemaPath(const std::string &schemaPath)
void require(int type, std::string ns, std::string name)
std::string getNamespace(std::string prefix)
std::string getAttributeValue(int index)
std::string getNamespaceUri(int pos)
std::string getAttributePrefix(int index)
int getNamespaceCount(int depth)
std::string getAttributeName(int index)
std::string getNamespacePrefix(int pos)
void setFeature(std::string feature, bool value)
const std::string SchemaUri
bool isValidWsdlElement(int id)
const std::string wsdlUri
bool WSDLPULL_EXPORT fetchUri(std::string uri, std::string &path)