Add our prefixes to the wsdl so that when users invoke methods
        and reference the prefixes, the will resolve properly.
482216
def pushprefixes(self):
        
        for ns in self.prefixes:
            self.wsdl.root.addPrefix(ns[0], ns[1])
1053573
private void addSimplifiers(List<Extractor> pHandlers, Extractor[] pSimplifyHandlers) {
        if (pSimplifyHandlers != null && pSimplifyHandlers.length > 0) {
            pHandlers.addAll(Arrays.asList(pSimplifyHandlers));
        } else {
            // Add all
            pHandlers.addAll(ServiceObjectFactory.<Extractor>createServiceObjects(SIMPLIFIERS_DEFAULT_DEF, SIMPLIFIERS_DEF));
        }
    }
111705
private void initializePrefixes()
	{
		if (namespaceMap == null) {
			// TODO use logger
			System.err
					.println("Cannot use whitespace filter without initializing the namespace-prefix map for the current Wikipedia language version. DISABLING FILTER.");
		}
		else {
			prefixesToAllow = new HashSet<String>();
			prefixesToReject = new HashSet<String>();

			for (Entry<Integer, String> namespace : namespaceMap.entrySet()) {
				if (allowedNamespaces.contains(namespace.getKey())) {
					prefixesToAllow.add(namespace.getValue() + ":");
				}
				else {
					prefixesToReject.add(namespace.getValue() + ":");
				}
			}
		}
	}
813768
private void addAffixes(char[] container, char[] prefix, char[] suffix) {

        // We add affixes only if needed (affix length > 0).
        int pl = prefix.length;
        int sl = suffix.length;
        if (pl != 0) prependPrefix(prefix, pl, container);
        if (sl != 0) appendSuffix(suffix, sl, container);

    }
486019
def _add_extra_handlers(self, handlers):
        
        extra_handlers = [(h[0], h[1], {"microservice": self}) for h in self.extra_handlers]
        handlers.extend(extra_handlers)
935029
public function prefix(string $prefix) : void
    {
        parent::prefix($prefix);
        $this->element->prefix($prefix);
    }
510624
public void addResolvedFrom(Context context) {
    context.getResolvedExpressions().forEach(this::addResolvedExpression);
    context.getResolvedFunctions().forEach(this::addResolvedFunction);
    context.getResolvedValues().forEach(this::addResolvedValue);
  }
43236
public void addNsBinding(String prefix, String uri)
    {
        // Unbind? (xml 1.1...)
        if ((uri == null) || (uri.length() == 0)) {
            uri = null;
        }

        // Default ns declaration?
        if ((prefix == null) || (prefix.length() == 0)) {
            prefix = null;
            mCurrElement.mDefaultNsURI = uri;
        }
        mNamespaces.addStrings(prefix, uri);
    }
1247531
def update(self, mapping, prefix=""):
        
        for k, v in mapping.items():
            self.set("%s%s" % (prefix, k), v)
1132676
def initializers(self, prefix: Optional[str] = None) -> List[str]:
        
        if self._type_reference:
            # This assumes that references are to things that have initializers
            # TODO: Remove this check once we are certian things are good
            ref = self._context.reference(self._type_reference)
            if not getattr(ref, 'signatures', None):
                raise NotImplementedError("Reference to " + self._type_reference + " is not valid")
            return self._context.reference(self._type_reference).initializers(prefix)
        else:
            return flatten([self._initializer_for(rn, cn, prefix) for rn, cn in self._names.items()])
112558
public void registerPrefixForNamespace(String prefix, String namespace) {
        getEnvironment().registerNamespace(prefix, getUrl(namespace));
    }
297544
def prefix(self, keys):
        
        assert isinstance(keys, tuple)

        self._prefix = keys
        self._load_prefix_binding()
856302
def resolve(self, event_handler, *custom_filters, **full_config
                ) -> typing.List[typing.Union[typing.Callable, AbstractFilter]]:
        
        filters_set = []
        filters_set.extend(self._resolve_registered(event_handler,
                                                    {k: v for k, v in full_config.items() if v is not None}))
        if custom_filters:
            filters_set.extend(custom_filters)

        return filters_set
152200
def _SetWsdlMethod(ns, wsdlName, inputMM):
   
   _wsdlMethodNSs.add(ns)
   curMM = _wsdlMethodMap.get( (ns, wsdlName) )
   # if inputMM is a list
   if isinstance(inputMM, list):
      if curMM is None:
         _wsdlMethodMap[(ns, wsdlName)] = inputMM
         return inputMM
      elif isinstance(curMM, list):
         raise RuntimeError(
                   "Duplicate wsdl method %s %s (new class %s vs existing %s)" % \
                   (ns, wsdlName, inputMM[0], curMM[0]))
      else:
         return curMM
   # if inputMM is a ManagedMethod
   else:
      if curMM is None or isinstance(curMM, list):
         _wsdlMethodMap[(ns, wsdlName)] = inputMM
         return inputMM
      else:
         return curMM
1353381
public void resolve() {
        //resolve class names at the end of adding all files to the tree
        for (GroovyClassDoc groovyClassDoc : classDocs.values()) {
            SimpleGroovyClassDoc classDoc = (SimpleGroovyClassDoc) groovyClassDoc;
            classDoc.resolve(this);
        }

    }
245422
protected void initBundlePrefixes() {
		bundlePrefixes = new CopyOnWriteArrayList<>();
		for (JoinableResourceBundle bundle : globalBundles) {
			if (StringUtils.isNotEmpty(bundle.getBundlePrefix())) {
				bundlePrefixes.add(bundle.getBundlePrefix());
			}
		}
		for (JoinableResourceBundle bundle : contextBundles) {
			if (StringUtils.isNotEmpty(bundle.getBundlePrefix())) {
				bundlePrefixes.add(bundle.getBundlePrefix());
			}
		}
	}
78288
def putSubHandler(self, prefix, handler):
        '''
        '''
        self.subHandlers[prefix] = handler
        handler._parent = self
        return self