def resolve(self, definitions):
        """
        Resolve named references to other WSDL objects.

        @param definitions: A definitions object.
        @type definitions: L{Definitions}

        """
        for op in self.operations.values():
            if op.input is None:
                op.input = Message(Element("no-input"), definitions)
            else:
                qref = qualify(op.input, self.root, definitions.tns)
                msg = definitions.messages.get(qref)
                if msg is None:
                    raise Exception("msg '%s', not-found" % (op.input,))
                op.input = msg
            if op.output is None:
                op.output = Message(Element("no-output"), definitions)
            else:
                qref = qualify(op.output, self.root, definitions.tns)
                msg = definitions.messages.get(qref)
                if msg is None:
                    raise Exception("msg '%s', not-found" % (op.output,))
                op.output = msg
            for f in op.faults:
                qref = qualify(f.message, self.root, definitions.tns)
                msg = definitions.messages.get(qref)
                if msg is None:
                    raise Exception("msg '%s', not-found" % (f.message,))
                f.message = msg

 def query(self, name):
     """ blindly query the schema by name """
     log.debug('searching schema for (%s)', name)
     schema = self.schema
     wsdl = self.wsdl()
     if wsdl is None:
         qref = qualify(name, schema.root, schema.tns)
     else:
         qref = qualify(name, wsdl.root, wsdl.tns)
     query = BlindQuery(qref)
     result = query.execute(schema)
     return (result, [])

    def resolveheaders(self, definitions, op):
        """
        Resolve SOAP header I{message} references.

        @param definitions: A definitions object.
        @type definitions: L{Definitions}
        @param op: An I{operation} object.
        @type op: I{operation}

        """
        soap = op.soap
        headers = soap.input.headers + soap.output.headers
        for header in headers:
            mn = header.message
            ref = qualify(mn, self.root, definitions.tns)
            message = definitions.messages.get(ref)
            if message is None:
                raise Exception("message '%s', not-found" % (mn,))
            pn = header.part
            for p in message.parts:
                if p.name == pn:
                    header.part = p
                    break
            if pn == header.part:
                raise Exception("message '%s' has not part named '%s'" % (
                    ref, pn))

 def __getref(self, a, tns):
     """ Get the qualified value of attribute named 'a'."""
     s = self.root.get(a)
     if s is None:
         return s
     else:
         return qualify(s, self.root, tns)  

    def do_resolve(self, definitions):
        """
        Resolve named references to other WSDL objects. Ports without SOAP
        bindings are discarded.

        @param definitions: A definitions object.
        @type definitions: L{Definitions}

        """
        filtered = []
        for p in self.ports:
            ref = qualify(p.binding, self.root, definitions.tns)
            binding = definitions.bindings.get(ref)
            if binding is None:
                raise Exception("binding '%s', not-found" % (p.binding,))
            if binding.soap is None:
                log.debug("binding '%s' - not a SOAP binding, discarded",
                    binding.name)
                continue
            # After we have been resolved, our caller will expect that the
            # binding we are referencing has been fully constructed, i.e.
            # resolved, as well. The only scenario where the operations binding
            # might possibly not have already resolved its references, and
            # where this explicit resolve() call is required, is if we are
            # dealing with a recursive WSDL import chain.
            binding.resolve(definitions)
            p.binding = binding
            filtered.append(p)
        self.ports = filtered

 def known(self, node):
     """ resolve type referenced by @xsi:type """
     ref = node.get('type', Namespace.xsins)
     if ref is None:
         return None
     qref = qualify(ref, node, node.namespace())
     query = BlindQuery(qref)
     return query.execute(self.schema)

 def resolveoppolicies(self, definitions, msg):
     policies = []
     for policy_name in msg.policies:
         ref = qualify(policy_name, self.root, definitions.tns)
         policy = definitions.policies.get(ref)
         if policy is None:
             raise Exception("policy '%s', not-found" % policy_name)
         else:
             policies.append(policy)
     msg.policies = policies

 def resolveport(self, definitions):
     """
     Resolve port_type reference.
     @param definitions: A definitions object.
     @type definitions: L{Definitions}
     """
     ref = qualify(self.type, self.root, definitions.tns)
     port_type = definitions.port_types.get(ref)
     if port_type is None:
         raise Exception("portType '%s', not-found" % self.type)
     else:
         self.type = port_type

 def qualify(self, name):
     """
     Qualify the name as either:
       - plain name
       - ns prefixed name (eg: ns0:Person)
       - fully ns qualified name (eg: {http://myns-uri}Person)
     @param name: The name of an object in the schema.
     @type name: str
     @return: A qualifed name.
     @rtype: qname
     """
     m = self.altp.match(name)
     if m is None:
         return qualify(name, self.wsdl.root, self.wsdl.tns)
     else:
         return (m.group(4), m.group(2))

 def resolve(self, definitions):
     """
     Resolve named references to other WSDL objects.
     Ports without soap bindings are discarded.
     @param definitions: A definitions object.
     @type definitions: L{Definitions}
     """
     filtered = []
     for p in self.ports:
         ref = qualify(p.binding, self.root, definitions.tns)
         binding = definitions.bindings.get(ref)
         if binding is None:
             raise Exception("binding '%s', not-found" % p.binding)
         if binding.soap is None:
             log.debug('binding "%s" - not a soap, discarded', binding.name)
             continue
         p.binding = binding
         filtered.append(p)
     self.ports = filtered

 def qualify(self):
     """
     Convert attribute values, that are references to other
     objects, into I{qref}.  Qualfied using default document namespace.
     Since many wsdls are written improperly: when the document does
     not define a default namespace, the schema target namespace is used
     to qualify references.
     """
     defns = self.root.defaultNamespace()
     if Namespace.none(defns):
         defns = self.schema.tns
     for a in self.autoqualified():
         ref = getattr(self, a)
         if ref is None:
             continue
         if isqref(ref):
             continue
         qref = qualify(ref, self.root, defns)
         log.debug('%s, convert %s="%s" to %s', self.id, a, ref, qref)
         setattr(self, a, qref)

    def __resolveport(self, definitions):
        """
        Resolve port_type reference.

        @param definitions: A definitions object.
        @type definitions: L{Definitions}

        """
        ref = qualify(self.type, self.root, definitions.tns)
        port_type = definitions.port_types.get(ref)
        if port_type is None:
            raise Exception("portType '%s', not-found" % (self.type,))
        # Later on we will require access to the message data referenced by
        # this port_type instance, and in order for those data references to be
        # available, port_type first needs to dereference its message
        # identification string. The only scenario where the port_type might
        # possibly not have already resolved its references, and where this
        # explicit resolve() call is required, is if we are dealing with a
        # recursive WSDL import chain.
        port_type.resolve(definitions)
        self.type = port_type

 def find(self, name, resolved=True):
     """
     Get the definition object for the schema object by name.
     @param name: The name of a schema object.
     @type name: str
     @param resolved: A flag indicating that the fully resolved type
         should be returned.
     @type resolved: boolean
     @return: The found schema I{type}
     @rtype: L{xsd.sxbase.SchemaObject}
     """
     log.debug('searching schema for (%s)', name)
     qref = qualify(name, self.schema.root, self.schema.tns)
     query = BlindQuery(qref)
     result = query.execute(self.schema)
     if result is None:
         log.error('(%s) not-found', name)
         return None
     log.debug('found (%s) as (%s)', name, Repr(result))
     if resolved:
         result = result.resolve()
     return result