WSDL.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  WSDL.qm Copyright (C) 2012 - 2020 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// make sure we have the required qore version
 
// requires XML functionality
 
// need mime definitions
 
 
// do not use $ for vars
 
// allow the use of the := weak reference assignment operator
 
 
 
/*
    WSDL classes
    provides some minimal WSDL and XSD support for SOAP messaging used by the SoapClient class and the SoapHandler
 
    not complete, needs namespace verification, improved XSD support, element groups, etc
*/
 
namespace WSDL {
    const version     = "0.3.6";
 
    const SOAP_11_ENV  = "http://schemas.xmlsoap.org/soap/envelope/";
    const SOAP_12_ENV  = "http://www.w3.org/2003/05/soap-envelope";
 
    const SOAP_11_NS   = "http://schemas.xmlsoap.org/wsdl/soap/";
 
    const SOAP_12_NS   = "http://schemas.xmlsoap.org/wsdl/soap12/";
 
    const XSD_NS       = "http://www.w3.org/2001/XMLSchema";
    const XSI_NS       = "http://www.w3.org/2001/XMLSchema-instance";
 
    const HTTP_NS      = "http://schemas.xmlsoap.org/wsdl/http/";
    const MIME_NS      = "http://schemas.xmlsoap.org/wsdl/mime/";
 
    const ENVELOPE_11_NS = (
        "soapenv:Envelope": (
            "^attributes^": (
                "xmlns:soapenv": SOAP_11_ENV,
                "xmlns:xsd": XSD_NS,
                "xmlns:xsi": XSI_NS,
            ),
        ),
    );
 
    const ENVELOPE_12_NS = (
        "soapenv:Envelope": (
            "^attributes^": (
                "xmlns:soapenv": SOAP_12_ENV,
              "xmlns:xsd": XSD_NS,
              "xmlns:xsi": XSI_NS,
            ),
        ),
    );
 
    const SoapUseMap = (
        "encoded": True,
        "literal": False,
    );
 
    const SoapStyleMap = (
        "document": True,
        "rpc": False,
    );
 
    const SOAP_ENCODING = "http://schemas.xmlsoap.org/soap/encoding/";
 
    const any_type_map = (
        Type::String      : "string",
        Type::Int         : "long",
        Type::Boolean     : "boolean",
        Type::Date        : "dateTime",
        Type::Float       : "decimal",
        Type::NothingType : "string",
        Type::NullType    : "string",
        Type::Binary      : "base64Binary",
    );
 
    // error codes
    const SOAP_SERIALIZATION_ERROR = "SOAP-SERIALIZATION-ERROR";
    const SOAP_DESERIALIZATION_ERROR = "SOAP-DESERIALIZATION-ERROR";
    const WSDL_ERROR = "WSDL-ERROR";
 
    const SOAP_TRANSPORT_HTTP = "http://schemas.xmlsoap.org/soap/http";
 
    const SOAP_TRANSPORT = (
        SOAP_TRANSPORT_HTTP: True,
    );
 
    const RANGE_SHORT = (-32768, 32767);
 
    const RANGE_INT = (-2147483648, 2147483647);
 
    // private global variables
    extern bool global_compat_empty_string_is_nothing;
    extern bool global_compat_allow_any_header;
 
     wsdl_set_global_compat_empty_string_is_nothing(softbool val);
 
 
     wsdl_set_global_compat_allow_any_header(softbool val);
 
};
 
class WSDL::WSDLLib {
 
public:
    const SoapMimeTypes = (MimeTypeSoapXml, MimeTypeXml, MimeTypeXmlApp);
 
      static string getSoapMimeType12(bool soap12);
 
 
      static data getFile(string fn, bool as_string = True);
 
 
      static string getHTTP(string url, *string path, *HTTPClient hc, *hash<auto> headers, bool as_string = True);
 
 
      static data getFTP(string url, string path, bool as_string = True);
 
 
      static data getFileFromURL(string url, string def_protocol = 'file', *HTTPClient http_client, *hash<auto> http_headers, bool as_string = True, *string def_path, *reference new_def_path);
 
 
      static data getFileFromURL(string url, hash<auto> u, string def_protocol = 'file', *HTTPClient http_client, *hash<auto> http_headers, bool as_string = False, *string def_path, *reference new_def_path);
 
      static WebService getWSDL(WebService wsdl);
 
 
      static string getWSDL(string wsdl, *HTTPClient http_client, *hash<auto> http_headers, *reference new_def_path);
 
 
      static WebService getWebServiceFromUrl(string url, *HTTPClient http_client, *hash<auto> http_headers);
 
      static hash<auto> parseMultiPartSOAPMessage(hash<auto> msg);
 
      static bool isSOAPMessage(hash<auto> msg);
 
      static *hash<auto> parseSOAPMessage(hash<auto> msg);
 
protected:
      static processHref(reference xmldata, string hr, hash<auto> parts);
public:
 
 
protected:
      static substHref(reference xmldata, hash<auto> parts);
public:
 
};
 
// private, nmon-exported class
class WsdlLibPriv {
 
public:
      static bool isContentType(string ct, list<auto> MimeTypes);
 
      static checkContentType(string ct, list<auto> MimeTypes);
};
 
class WSDL::XsdBase : public Qore::Serializable {
 
public:
      static removeNS(reference v);
 
      static removeNS2(reference v);
};
 
class WSDL::XsdData : public WSDL::XsdBase {
 
public:
    auto getValue(*hash<auto> mrh, auto val);
 
};
 
class WSDL::XsdNamedData : public WSDL::XsdData {
 
public:
        // name of object
        string name;
        *string ns;
        descriptive_name;
 
    constructor(string n_name, string n_ns);
 
 
    constructor(reference e, *string desc_name);
 
 
    string getName();
 
 
    *string getInputNamespacePrefix();
 
 
    bool hasRealName();
 
};
 
class WSDL::XsdAbstractType : public WSDL::XsdNamedData {
 
public:
        Namespaces nsc;
 
        string ons;
 
    constructor(reference e, Namespaces nsc, *string desc_name) ;
 
 
    constructor(string name, string ns, Namespaces nsc) ;
 
 
protected:
     resolveNamespace();
public:
 
 
    checkExtends(XsdAbstractType t, string ename);
 
 
    string getNameWithNS();
 
 
    bool isNillable();
 
 
    bool isRequired();
 
 
    bool requiresValue();
 
 
    string getOutputNamespacePrefix();
 
 
    abstract auto serialize(Namespaces nsc, auto val, *softbool omitType);
    abstract auto deserialize(string en, hash<string, XsdAbstractType> tmap, *hash<auto> mrh, auto val);
    abstract AbstractDataProviderType getDataProviderType();
};
 
class WSDL::XsdBaseType : public WSDL::XsdAbstractType {
 
public:
 
    constructor(string t, Namespaces nsc, string ns = 'xsd') ;
 
 
    auto serialize(Namespaces nsc, auto val, *softbool omitType);
 
 
    auto deserialize(string en, hash<string, XsdAbstractType> tmap, *hash<auto> mrh, auto val);
 
 
    AbstractDataProviderType getDataProviderType();
 
 
    Type getDataProviderBaseType();
 
};
 
class WSDL::XsdArrayType : public WSDL::XsdAbstractType {
 
public:
protected:
        bool finalized;
 
public:
 
        *hash<auto> typeinfo;
        XsdAbstractType elementType;
 
    constructor(string t, string ns, string arrayType, Namespaces nsc, XsdLateResolverHelper unresolved) ;
 
 
    AbstractDataProviderType getDataProviderType();
 
 
    finalize(hash<string, XsdAbstractType> tmap, Namespaces nsc);
 
 
    auto serialize(Namespaces nsc, auto val, *softbool omitType);
 
 
    auto deserialize(string en, hash<string, XsdAbstractType> tmap, *hash<auto> mrh, auto val);
 
};
 
class WSDL::XsdTypedData : public WSDL::XsdNamedData {
 
public:
        *hash<auto> typeinfo;
        XsdAbstractType type;
 
    constructor(reference e) ;
 
};
 
class WSDL::XsdAttribute : public WSDL::XsdTypedData {
 
public:
        string use = "optional";
 
        const AllowedUseValues = (
            "optional": True,
            "required": True,
            "prohibited": True,
            );
 
    constructor(hash<auto> attr, Namespaces nsc, *XsdAbstractType n_type, XsdLateResolverHelper unresolved) ;
 
 
    auto getValue(string val);
 
};
 
class WSDL::XsdElement : public WSDL::XsdTypedData {
 
public:
        int minOccurs = 1;
        int maxOccurs = 1;
        bool nillable = False;
        // the resolved namespace URI for any reference
        *string ref_ns;
        // the source name for any reference
        *string ref;
        bool usedocns;
 
    constructor(hash<auto> e, Namespaces nsc, *XsdAbstractType n_type, XsdLateResolverHelper unresolved, bool n_usedocns) ;
 
 
    AbstractDataProviderType getDataProviderType();
 
 
    assimilate(WSDL::XsdElement other);
 
 
    bool isRequired();
 
 
    bool isNillable();
 
 
    auto serialize(Namespaces nsc, auto h, *softbool omitType, string key, string typename);
 
 
protected:
     auto serializeAsIntern(Namespaces nsc, XsdAbstractType type, auto h, *softbool omitType, string key, string typename);
public:
 
 
    auto deserialize(hash<string, XsdAbstractType> tmap, *hash<auto> mrh, auto val, bool present);
 
};
 
class WSDL::XsdSimpleType : public WSDL::XsdAbstractType {
 
public:
        hash<auto> enum;
        hash<auto> typeinfo;
        list<hash<auto>> union;
        list<XsdAbstractType> unionTypes;
        XsdSimpleType unionSimpleType;
        XsdAbstractType type;
        bool usedocns;
 
    constructor(hash<auto> st, Namespaces nsc, XsdLateResolverHelper unresolved, bool n_usedocns, *string desc_name) ;
 
 
    AbstractDataProviderType getDataProviderType();
 
 
    auto serialize(Namespaces nsc, auto val, *softbool omitType);
 
 
    auto deserialize(string en, hash<string, XsdAbstractType> tmap, *hash<auto> mrh, auto val);
 
};
 
public hashdecl WSDL::ChoiceInfo {
    hash<string, XsdElement> elementmap;
    bool required;
};
 
class WSDL::XsdComplexType : public WSDL::XsdAbstractType {
 
public:
        *XsdArrayType array;
        *string arrayType;
        *string restriction;
        *string extension;
 
        bool usedocns;
 
        hash<string, XsdElement> elementmap();
        bool anyAttribute = False;
 
        bool nillable = False;
        bool required = False;
        bool requires_value = False;
 
        // attributes
        hash<string, XsdAttribute> attrs();
 
        // any annotated documentation
        *string documentation;
 
        // temporarily used to store type information to resolve simpleType
        *hash<auto> simpleTypeInfo;
        // simpleContent type
        XsdAbstractType simpleType;
 
        // finalization flag
        bool finalized = False;
 
        // multiple choice blocks
        list<hash<ChoiceInfo>> choices();
 
protected:
        string cx_type;
 
        const XET_ALL      = "ALL";
        const XET_CHOICE   = "CHOICE";
        const XET_SEQUENCE = "SEQUENCE";
        const XET_SIMPLE   = "SIMPLE";
        const XET_NONE     = "NONE";
 
public:
 
    // ct can be NOTHING in case of an empty complex type
    constructor(*hash<auto> ct, Namespaces nsc, XsdLateResolverHelper unresolved, bool n_usedocns, *string desc_name) ;
 
 
    finalize(hash<string, XsdAbstractType> tmap, Namespaces nsc);
 
 
    checkExtends(XsdAbstractType t, string ename);
 
 
protected:
     parseData(hash<auto> d, XsdLateResolverHelper unresolved, Namespaces nsc);
public:
 
 
protected:
     parseAttributes(reference d, XsdLateResolverHelper unresolved, Namespaces nsc);
public:
 
 
    bool isNillable();
 
 
    bool isRequired();
 
 
    bool requiresValue();
 
 
    bool isEmpty();
 
 
protected:
     hash<string, XsdElement> parseElements(softlist<auto> el, XsdLateResolverHelper unresolved, Namespaces nsc, bool for_object = True);
public:
 
 
    AbstractDataProviderType getDataProviderType();
 
 
protected:
     *hash<auto> serializeElement(Namespaces nsc, string key, XsdElement element, auto h, *softbool omitType);
public:
 
 
    *hash<auto> serialize(Namespaces nsc, auto h, *softbool omitType);
 
 
protected:
     hash<auto> serializeChoice(Namespaces nsc, hash<string, XsdElement> emap, hash<auto> h, *softbool omitType, bool all_members);
public:
 
 
    *hash<auto> deserialize(string en, hash<string, XsdAbstractType> tmap, *hash<auto> mrh, auto oval);
 
 
protected:
     *hash<auto> parseChoice(hash<auto> val, hash<string, XsdElement> emap, string en, hash<string, XsdAbstractType> tmap, *hash<auto> mrh, *bool required);
public:
 
};
 
class WSDL::WSOperation : public WSDL::XsdNamedData {
 
public:
        WSMessage input;
        WSMessage output;
        *string input_name;
        *string output_name;
 
        Namespaces nsc;
 
        *string soapAction;
 
        hash<string, bool> reqh;
 
        hash<string, OperationalBinding> bindings;
 
protected:
        hash<string, WSMessage> faults;
 
public:
 
 
    constructor(hash<auto> p, Namespaces nsc, *hash<auto> messages) ;
 
 
    *hash<string, WSMessage> getFaultMessages();
 
 
    bool hasFault(string fault);
 
 
    setDocStyleBinding(reference idocmap);
 
 
    markRpcStyleBinding();
 
 
    list<auto> getTopLevelRequestNames();
 
 
 
    OperationalBinding getBinding(*string bname);
 
 
 
    addBinding(WSDL::OperationalBinding b);
 
 
 
    hash<auto> serializeFault(*string fault, string faultmsg, auto h, *hash<auto> header, *string enc, *hash<auto> nsh, *int xml_opts, *string req_soapaction, *string bname);
 
 
 
    hash<auto> serializeRequest(auto h, *hash<auto> header, *string enc, *hash<auto> nsh, *int xml_opts, *string req_soapaction, *string bname, *hash<auto> http_headers);
 
 
 
    hash<auto> serializeResponse(auto h, *hash<auto> header, *string enc, *hash<auto> nsh, *bool soap12, *int xml_opts, *string bname, *hash<auto> http_headers);
 
 
 
    auto deserializeRequest(hash<auto> o, *string bname);
 
 
 
    auto deserializeResponse(hash<auto> o, *string bname);
 
 
    *hash<auto> deserializeRequestPath(string path, *string bname);
 
 
protected:
      static hash<auto> processNSValue(hash<auto> h);
public:
 
 
 
    bool isSoap12();
 
 
 
    string getTargetNS();
 
};
 
public hashdecl WSDL::ArgInfo {
    string name;
 
    string part;
 
    XsdAbstractType type;
 
    XsdElement element;
};
 
 
class WSDL::WSMessage : public WSDL::XsdNamedData {
 
public:
        hash<string, hash<WSDL::ArgInfo>> args;
 
        hash<string, string> pmap;
 
        hash<string, XsdAbstractType> tmap;
 
        // keep a weak reference to the namespace map
        Namespaces nsc;
 
    constructor(hash<auto> m, hash<string, hash<string, XsdElement>> emap, hash<string, XsdAbstractType> tmap, Namespaces nsc) ;
 
 
    AbstractDataProviderType getDataProviderType();
 
 
    auto serializeRpcValue(string part, bool encoded, reference<hash<auto>> h, reference<string> ons);
 
 
 
    *hash<auto> serializeRpc(*softlist<auto> parts, *WSDL::BindingMessageDescription msginfo, *MultiPartRelatedMessage mpm, string n_name, bool encoded, reference<auto> h, bool fault);
 
 
 
    *hash<auto> serializeDocument(*softlist<auto> parts, *WSDL::BindingMessageDescription msginfo, *MultiPartRelatedMessage mpm, bool encoded, reference<auto> h, bool fault);
 
 
 
    *hash<auto> deserializeRpc(*hash<auto> mrh, hash<auto> val, *string part);
 
 
    *hash<auto> deserializeDocument(*hash<auto> mrh, auto val, *string parts);
 
 
 
    hash<auto> serializeAllPartData(*hash<auto> val);
 
 
 
    hash<auto> serializeData(Namespaces nsc, string key, *hash<auto> val);
 
 
 
    hash<auto> deserializeData(string part, hash<auto> val);
 
 
 
    hash<auto> deserializeAllPartData(hash<auto> val);
 
 
 
private:
     auto getValueFromHash(string ename, reference<auto> v, bool removeFound);
public:
 
 
private:
     auto getValueFromHash(*WSDL::XsdElement element, reference<auto> v, bool removeFound);
public:
 
 
    string getSerializedKey(string part);
 
 
 
    string checkPart(string pname);
 
};
 
// private helper class for lazy name resolution
class WSDL::XsdLateResolverHelper {
 
public:
protected:
        list<object> l();
 
public:
 
    constructor();
 
 
    add(object v);
 
 
    list<auto> getList();
 
 
    clearResolved();
 
 
      static bool isResolved(XsdTypedData t);
 
      static bool isResolved(XsdSimpleType t);
 
      static bool isResolved(XsdComplexType t);
 
      static bool isResolved(XsdArrayType t);
 
      static bool isResolved(auto t);
};
 
class WSDL::OperationalBinding : public WSDL::XsdNamedData {
 
public:
        bool docstyle;
        *WSDL::BindingMessageDescription input;
        *WSDL::BindingMessageDescription output;
        *string soapAction;
 
    constructor(string name, string ns, bool docstyle, *string soapAction, *WSDL::BindingMessageDescription input, *WSDL::BindingMessageDescription output) ;
 
 
    hash<auto> serializeMessage(WSOperation op, *WSMessage msg, bool request, bool soap12, auto h, *hash<auto> header, string enc = 'UTF-8', *hash<auto> nsh, *int xml_opts, *string req_soapaction, *string faultmsg, *hash<auto> http_headers);
 
 
    auto deserializeMessage(WSOperation op, hash<auto> o, bool request);
 
 
    auto deserializeRequestPath(WSOperation op, string path);
 
 
    abstract hash<auto> serializeMessageImpl(WSOperation op, *WSMessage msg, bool request, bool soap12, auto h, *hash<auto> header, string enc, *hash<auto> nsh, *int xml_opts, *string req_soapaction, *string faultmsg, *hash<auto> http_headers);
 
    abstract auto deserializeMessageImpl(WSOperation op, hash<auto> o, bool request);
 
    abstract auto deserializeRequestPathImpl(WSOperation op, string path);
};
 
class WSDL::SoapBinding : public WSDL::OperationalBinding {
 
public:
        string soapTransport;
 
    constructor(string name, string ns, bool docstyle, string soapTransport, *string soapAction, *WSDL::BindingMessageDescription input, *WSDL::BindingMessageDescription output) ;
 
 
    hash<auto> serializeMessageImpl(WSOperation op, *WSMessage msg, bool request, bool soap12, auto h, *hash<auto> header, string enc, *hash<auto> nsh, *int xml_opts, *string req_soapaction, *string faultmsg, *hash<auto> http_headers);
 
 
private:
     hash<auto> serializeSoapMessage(WSOperation op, *WSMessage msg, auto val, *hash<auto> header, *hash<auto> nsh, bool request, bool soap12, reference mpm, *string faultmsg);
public:
 
 
    auto deserializeMessageImpl(WSOperation op, hash<auto> orig_msg, bool request);
 
 
private:
      static list<auto> processMultiRef(hash<auto> body);
public:
 
 
    hash<auto> deserializeRequestPathImpl(WSOperation op, string path);
 
};
 
class WSDL::HttpBinding : public WSDL::OperationalBinding {
 
public:
        string httpMethod;
        string location;
 
    constructor(string name, string ns, bool docstyle, string httpMethod, string location, *string soapAction, *WSDL::BindingMessageDescription input, *WSDL::BindingMessageDescription output) ;
 
 
    hash<auto> serializeMessageImpl(WSOperation op, *WSMessage msg, bool request, bool soap12, auto h, *hash<auto> header, string enc, *hash<auto> nsh, *int xml_opts, *string req_soapaction, *string faultmsg, *hash<auto> http_headers);
 
 
private:
     string serializeRequestPath(WSOperation op, auto h);
public:
 
 
    auto deserializeMessageImpl(WSOperation op, hash<auto> v, bool request);
 
 
    hash<auto> deserializeRequestPathImpl(WSOperation op, string path);
 
};
 
 
class WSDL::BindingMessageBodyDescription : public Serializable {
 
public:
 
        bool encoded;
 
        *string encodingStyle;
 
        *string ns;
 
        *list<auto> parts;
 
    constructor(bool encoded, *string encodingStyle, *string ns, *string parts);
 
 
    bool isMultipart();
 
};
 
class WSDL::BindingMessageHeaderDescription : public Serializable {
 
public:
        string part;
 
 
        bool encoded;
 
        WSMessage msg;
 
    /*
        @param part message part name
        @param encoded if @ref Qore::True "True", then use = \c "encoded" (each message part references an abstract type using the \c type attribute), otherwise use = \c "literal" (each part references a concrete schema definition using either the \c element or \c type attribute)
        @param msg actual message
    */
    constructor(string part, bool encoded = False, WSMessage msg);
 
};
 
 
class WSDL::BindingContentDescription : public Serializable {
 
public:
        string part;
 
        // list of accepted content types (with "xxx/*")
        list<auto> acceptedContentTypes = ();
 
        // list of accepted specific content types
        list<auto> acceptedContentTypeSubtypes = ();
 
        bool formUrlEncoded = False;
 
        bool acceptAllContentTypes = False;
 
    addContentType(string type);
 
};
 
 
class WSDL::MimeXmlMessageDescription : public Serializable {
 
public:
 
        string part;
 
    constructor(string part);
 
};
 
class WSDL::BindingMessageDescription : public Serializable {
 
public:
        *WSDL::BindingMessageBodyDescription body;
 
 
        *hash<auto> urlReplacement;
 
 
        bool urlEncoded = False;
 
        *WSDL::BindingContentDescription content;
 
        *WSDL::MimeXmlMessageDescription mimeXml;
 
private:
        list<BindingMessageHeaderDescription> headers = cast<list<BindingMessageHeaderDescription>>(());
 
public:
 
    addHeader(BindingMessageHeaderDescription hdr);
 
 
    bool hasHeaders();
 
 
    list<BindingMessageHeaderDescription> getHeaders();
 
 
    setUrlReplacement(string loc);
 
};
 
class WSDL::Binding : public WSDL::XsdNamedData {
 
public:
private:
        string port;
 
 
        bool docstyle = True;
 
        *string httpMethod;
        *string soapTransport;
 
public:
 
    constructor(hash<auto> data, Namespaces nsc, reference portTypes, reference idocmap, *hash<auto> messages) ;
 
 
private:
     string checkMessagePart(WSMessage msg, *string partname, string errs);
public:
 
 
    string getPort();
 
 
    bool isSoapBinding();
 
 
    bool isHttpBinding();
 
};
 
// private namespace prefix redefinition class
class WSDL::NamespacePrefixHelper {
 
public:
 
protected:
        Namespaces nsc;
 
        // overriden prefixes
        hash<auto> h;
 
        // overridden target namespace
        bool targ_ns;
 
        // overridden default namespace
        bool def_ns;
 
public:
 
    constructor(Namespaces nsc, *hash<auto> nsattr);
 
 
    destructor();
 
 
    save(string k, string v);
 
};
 
class WSDL::Namespaces : public Serializable {
 
public:
        // options are here since this object is passed through all serialization and deserialization
        bool opt_empty_string_is_nothing = False;
        bool opt_allow_any_header = False;
 
protected:
        hash<string, string> ns = {
            "xsd": XSD_NS,
        };
 
        hash<string, string> nsr = {
            XSD_NS: "xsd",
        };
 
        hash<string, bool> xsd_schema = {
            "xsd": True,
        };
 
        hash<string, string> imap = {
            "xsd": XSD_NS,
        };
 
        hash<string, string> imapr = {
            XSD_NS: "xsd",
        };
 
        bool hassoap11 = False;
 
        bool hassoap12 = False;
 
        *string target_ns;
 
        list<auto> nss = ();
 
        *string default_ns;
 
        list<auto> dss = ();
 
        hash<string, XsdBaseType> base_types;
 
        const DefaultPrefixes = {
            SOAP_ENCODING: "soapenc",
            XSD_NS: "xsd",
            XSI_NS: "xsi",
            SOAP_11_ENV: "soapenv",
            SOAP_12_ENV: "soapenv",
            MIME_NS: "mime",
            HTTP_NS: "http",
        };
 
public:
 
    constructor(hash<auto> nsh, *Namespaces nsc, *string targetNamespace);
 
 
    *string getDefaultNs();
 
 
    addNamespaces(hash<auto> nsh, *NamespacePrefixHelper nph);
 
 
    restorePrefixes(hash<auto> h);
 
 
protected:
     addNamespaceIntern(string ns, string val, *bool override);
public:
 
 
    merge(Namespaces nsc);
 
 
    string getUniquePrefix(string uri, *string default_prefix);
 
 
    string getOutputNamespaceUri(string nsp);
 
 
    *hash<auto> getOutputNamespaceHash(*hash<auto> nsh);
 
 
    *string getTargetNamespaceUri();
 
 
    *string getNamespaceUri(*string nsp);
 
 
    pushTargetNamespace(string ns);
 
 
    popTargetNamespace();
 
 
    pushDefaultNamespace(string ns);
 
 
    popDefaultNamespace();
 
 
    string getOutputNamespacePrefix(string ns);
 
 
    string getTargetNamespaceOutputPrefix();
 
 
    string getTargetNamespaceInputPrefix();
 
 
protected:
     string registerNamespaceIntern(string uri, *string default_pfx);
public:
 
 
    *hash<auto> getReferencedNamespaceMap();
 
 
    bool hasSoap11();
 
 
    bool hasSoap12();
 
 
    *bool isSchema(string ns);
 
 
    string getInputNamespaceUri(string nsa);
 
 
    bool doType(string t, reference<hash> typeinfo, reference<XsdAbstractType> rtype, *hash<string, XsdAbstractType> tmap);
 
 
    hash<auto> getTypeHash(string t);
 
 
    XsdBaseType getBaseType(string t);
 
 
    string translateOutputNamespacePrefix(*string nsa);
 
};
 
// private functions
XsdAbstractType tmap_get(hash<string, XsdAbstractType> tmap, string name);
 
 
*XsdAbstractType tmap_try_get(hash<string, XsdAbstractType> tmap, string name);
 
 
// private functions
XsdElement emap_get(hash<string, hash<string, XsdElement>> emap, string ns, string name);
 
 
*XsdElement emap_try_get(hash<string, hash<string, XsdElement>> emap, string ns, string name);
 
 
public hashdecl WSDL::PortTypeInfo {
    hash<string, WSOperation> operations;
};
 
public hashdecl WSDL::ServiceInfo {
    string name;
    hash<string, hash> port;
};
 
public hashdecl WSDL::OperationInfo {
    string port;
 
    WSDL::WSOperation operation;
};
 
 
class WSDL::WebService : public WSDL::XsdBase,public  Qore::Serializable {
 
public:
        string wsdl;
 
        *hash<auto> opts;
 
        bool has_try_import = False;
 
 
        string name;
 
 
        string hash_str;
 
        transient Namespaces nsc;
 
        transient list<string> wsdl_services();
 
        transient hash<string, XsdElement> idocmap();
 
        transient hash<string, hash<string, XsdElement>> emap();
 
        transient hash<string, WSMessage> messages();
 
        transient hash<string, XsdAbstractType> tmap();
 
        transient hash<string, hash<PortTypeInfo>> portType();
 
        transient *code try_import;
 
 
        transient *string def_path;
 
protected:
        // service definitions; name -> service info hash
        hash<string, hash<WSDL::ServiceInfo>> services();
 
        // service bindings; name -> Binding
        hash<string, Binding> binding();
 
public:
 
 
    constructor(string str, *hash<auto> opts);
 
 
 
    string getName();
 
 
 
      synchronized string getHash();
 
 
    WSDL::WSOperation getOperation(string opname);
 
 
    softlist<string> getOperationNames();
 
 
    WSDL::WSOperation getPortTypeOperation(string ptname, string opname);
 
 
    WSDL::WSOperation getBindingOperation(*string bname, string opname);
 
 
 
    list<hash<OperationInfo>> listOperations();
 
 
 
    WSDL::Binding getBinding(string name);
 
 
 
    list<hash<WSDL::ServiceInfo>> listServices();
 
 
 
    hash<WSDL::ServiceInfo> getService(string name);
 
 
    hash<auto> getType(string name, auto v);
 
 
protected:
     XsdBaseType getBaseType(string t);
public:
 
 
protected:
     resolveType(XsdSimpleType t);
public:
 
 
protected:
     resolveType(XsdElement xe);
public:
 
 
protected:
     resolveType(XsdAttribute xd);
public:
 
 
protected:
     resolveType(XsdComplexType ct);
public:
 
 
protected:
     resolveType(XsdArrayType t);
public:
 
 
protected:
     XsdAbstractType resolveType(hash<auto> v);
public:
 
 
    // parse XSD schema types
protected:
     parseTypes(*hash<auto> data, auto http_client, auto http_headers);
public:
 
 
protected:
     parseMessages(*softlist<auto> message);
public:
 
 
protected:
     parseService(*softlist<auto> svcs);
public:
 
 
protected:
     parsePortType(*softlist<auto> data);
public:
 
 
protected:
     parseBinding(*softlist<auto> bindings);
public:
 
 
 
    bool isSoap12();
 
 
 
    string getWSDL();
 
 
 
    string getWSDL(string base_url);
 
 
protected:
     string getOperationParams(WSMessage msg);
public:
 
 
 
    getReport(StringOutputStream stream, *string wsdl_name);
 
 
 
    string getReport(*string wsdl_name);
 
 
 
private:
     doInit(string str, *hash<auto> opts);
public:
 
 
 
private:
     deserializeMembers(hash<auto> members);
public:
 
};
 
 
class WSDL::WSMessageHelper {
 
public:
protected:
        WebService ws;
        hash<auto> opts;
 
public:
 
    const DefaultOpts = (
        "comments": False,
        "choices": False,
        "max_items": 3,
    );
 
 
    constructor(WebService ws, *hash<auto> opts);
 
 
protected:
     hash<auto> getTypeInfo(XsdBaseType t);
public:
 
 
protected:
     hash<auto> getTypeInfo(XsdSimpleType t);
public:
 
 
protected:
     hash<auto> getTypeInfo(XsdComplexType t);
public:
 
 
    hash<auto> getMessage(XsdElement elem, *softlist<auto> comments);
 
 
 
    hash<auto> getMessage(string name);
 
 
 
    auto getMessage(WSMessage msg);
 
};