/*
(non-Javadoc)

@see javax.xml.ws.handler.HandlerResolver#getHandlerChain(javax.xml.ws.handler.PortInfo)
422963
@SuppressWarnings("rawtypes")
    @Override
    public List<Handler> getHandlerChain(PortInfo paramPortInfo) {
        List<Handler> handlers = handlersMap.get(paramPortInfo);

        if (handlers == null) {
            handlers = createHandlerFromHandlerInfo(paramPortInfo);
            handlersMap.put(paramPortInfo, handlers);
        }
//        return Collections.unmodifiableList(handlers);
        return handlers;
    }
475624
public MultiMEProxyHandler getProxyHandler() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled()) {
            SibTr.entry(tc, "getProxyHandler");
            SibTr.exit(tc, "getProxyHandler", _multiMEProxyHandler);
        }

        return _multiMEProxyHandler;
    }
1244990
private Chain<ApiRequest> createRequestChain(IAsyncHandler<ApiRequest> requestHandler) {
        RequestChain chain = new RequestChain(policyImpls, context);
        chain.headHandler(requestHandler);
        chain.policyFailureHandler(failure -> {
            // Jump straight to the response leg.
            // It will likely not have been initialised, so create one.
            if (responseChain == null) {
                // Its response will not be used as we take the failure path only, so we just use an empty lambda.
                responseChain = createResponseChain((ignored) -> {});
            }
            responseChain.doFailure(failure);
        });
        chain.policyErrorHandler(policyErrorHandler);
        return chain;
    }
699859
protected String getPort() {
        String port = tomcatPort;
        if (mavenTomcatPort != null) {
            port = mavenTomcatPort;
            getLog().info( "Tomcat Port overridden by property maven.tomcat.port");
        }

        return port;
    }
359262
protected PrincipalResolver getPrincipalResolverLinkedToHandlerIfAny(final AuthenticationHandler handler, final AuthenticationTransaction transaction) {
        return this.authenticationEventExecutionPlan.getPrincipalResolverForAuthenticationTransaction(handler, transaction);
    }
507547
public MQLinkHandler getMQLinkHandler() 
  {
    if (tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getMQLinkHandler");
      SibTr.exit(tc, "getMQLinkHandler", _mqLinkHandler);
    }    
    return _mqLinkHandler;
  }
430901
protected XATransactionWrapper getXATransactionWrapper() throws ResourceException {

        final boolean isTracingEnabled = TraceComponent.isAnyTracingEnabled();

        if (isTracingEnabled && tc.isEntryEnabled()) {
            Tr.entry(this, tc, "getXATransactionWrapper");
        }

        if (xaTranWrapper == null) {
            boolean isJDBC41 = false;
            if (mc instanceof WSManagedConnection) {
                if (_managedConnectionFactory instanceof WSManagedConnectionFactory
                    && (((WSManagedConnectionFactory) _managedConnectionFactory).getJDBCRuntimeVersion().compareTo(new Version(4, 1, 0))) >= 0) {
                    isJDBC41 = true;
                }
            }
            if (isJDBC41) {
                xaTranWrapper = new AbortableXATransactionWrapper(this);
            } else {
                xaTranWrapper = new XATransactionWrapper(this);
            }
        }

        // Move the xaTranWrapper.initialize() call outside of the above "xaTranWrapper == null"
        // conditional.  Prior to this change, the xaResource within the xaTranWrapper was not
        // getting re-initialized for MCWrappers that were pulled from the MCWrapperPool.  This
        // call to initialize() for existing xaTranWrappers is safe and quick since we check
        // for an existing xaResource as the first thing in initialize().
        //
        xaTranWrapper.initialize();

        if (state == STATE_ACTIVE_INUSE) {
            state = STATE_TRAN_WRAPPER_INUSE;
            tranWrapperInUse = XATXWRAPPER;
        } else { // state not STATE_ACTIVE_INUSE
            if (state != STATE_TRAN_WRAPPER_INUSE) {
                IllegalStateException e = new IllegalStateException("getXATransactionWrapper: illegal state exception. State = " + getStateString() + " MCW = "
                                                                    + mcWrapperObject_hexString);
                Tr.error(tc, "ILLEGAL_STATE_EXCEPTION_J2CA0079", "getXATransactionWrapper", e);
                throw e;
            } else { // state is STATE_TRAN_WRAPPER_INUSE
                if (tranWrapperInUse == NONE) {
                    tranWrapperInUse = XATXWRAPPER;
                } else { //tranWrapperInUse is NOT NONE
                    if (tranWrapperInUse != XATXWRAPPER) {
                        // Need RAS and Trace here.
                        IllegalStateException e = new IllegalStateException("getXATransactionWrapper: illegal transaction state exception. State = "
                                                                            + getTranWrapperString());
                        Tr.error(tc, "ILLEGAL_STATE_EXCEPTION_J2CA0079", "getXATransactionWrapper", e);
                        throw e;
                    }
                }
            }
        }

        if (isTracingEnabled && tc.isEntryEnabled()) {
            Tr.exit(this, tc, "getXATransactionWrapper");
        }

        return xaTranWrapper;
    }
1068271
@SuppressWarnings("unchecked")
    public HttpServletRequest getChainedRequest() throws IOException, ServletException{
        if (super.containsError())
        {
            throw super.getError();
        }
        ChainedRequest req = new ChainedRequest(this, _req);
        //transfer any auto transfer headers
        Hashtable headers = getAutoTransferringHeaders();
        Enumeration names = headers.keys();
        while (names.hasMoreElements())
        {
            String name = (String)names.nextElement();
            String value = (String)headers.get(name);
            req.setHeader(name, value);
        }

        //get headers from response and add to request
        Iterable<String> headerNames = getHeaderNames();
        for (String name:headerNames)
        {
            String value = (String)getHeader(name);
            req.setHeader(name, value);
        }


        return req;
    }
1335808
public static List<String> getDefaultConversionProviderChain(){
        List<String> defaultChain = getMonetaryConversionsSpi()
                .getDefaultProviderChain();
        Objects.requireNonNull(defaultChain, "No default provider chain provided by SPI: " +
                getMonetaryConversionsSpi().getClass().getName());
        return defaultChain;
    }
1216585
protected RequestSecurityProcessor getLastProcessorInChain(final FilterChain chain) {
        return new RequestSecurityProcessor() {

            public void processRequest(RequestContext context, RequestSecurityProcessorChain processorChain) throws
                Exception {
                chain.doFilter(context.getRequest(), context.getResponse());
            }

        };
    }
267680
public CFEndPoint getEndPoint() throws ChannelFrameworkException {
        if (null == this.endPoint) {
            if (FlowType.INBOUND.equals(this.type)) {
                this.endPoint = new CFEndPointImpl(this);
            } else {
                throw new ChannelFrameworkException(this.name + " is not inbound chain");
            }
        }
        return this.endPoint;
    }
1365755
public final LinkHandler getLink(String linkName)
    {
        LinkTypeFilter filter = new LinkTypeFilter();
        return (LinkHandler) linkIndex.findByName(linkName, filter);
    }
1023543
public HBaseDataHandler getHandle()
    {
        HBaseDataHandler handler = new HBaseDataHandler(this.kunderaMetadata, this.connection);
        handler.filter = this.filter;
        handler.filters = this.filters;
        return handler;
    }
169814
public BaseDestinationHandler getDestinationHandler()
  {
    if (tc.isEntryEnabled())  
    {
      SibTr.entry(tc, "getDestinationHandler");
      SibTr.exit(tc, "getDestinationHandler", destinationHandler);
    }      
    return destinationHandler;
  }
975194
@Override
    public ControlHandler getControlHandler(
                                            ProtocolType type, SIBUuid8 sourceMEUuid, ControlMessage msg)
    {
        throw new InvalidOperationException(
                        nls.getFormattedMessage(
                                                "INTERNAL_MESSAGING_ERROR_CWSIP0005",
                                                new Object[] { "AbstractAliasDestinationHandler",
                                                              "1:681:1.67.1.22",
                                                              getBus() + " : " + getName() },
                                                null));
    }
358401
double getChainArea(int chain) {
		int chainIndex = getChainIndex_(chain);
		double v = m_chainAreas.read(chainIndex);
		if (NumberUtils.isNaN(v)) {
			updateChainAreaAndPerimeter_(chain);
			v = m_chainAreas.read(chainIndex);
		}

		return v;
	}
198134
private static void addPathChain(PathChain pathChain) {
		HttpString method = new HttpString(pathChain.getMethod());

		// Use a random integer as the id for a given path.
		Integer randInt = new Random().nextInt();
		while (handlerListById.containsKey(randInt.toString())) {
			randInt = new Random().nextInt();
		}

		// Flatten out the execution list from a mix of middleware chains and handlers.
		List<HttpHandler> handlers = getHandlersFromExecList(pathChain.getExec());
		if(handlers.size() > 0) {
			// If a matcher already exists for the given type, at to that instead of
			// creating a new one.
			PathTemplateMatcher<String> pathTemplateMatcher = methodToMatcherMap.containsKey(method)
				? methodToMatcherMap.get(method)
				: new PathTemplateMatcher<>();

			if(pathTemplateMatcher.get(pathChain.getPath()) == null) { pathTemplateMatcher.add(pathChain.getPath(), randInt.toString()); }
			methodToMatcherMap.put(method, pathTemplateMatcher);
			handlerListById.put(randInt.toString(), handlers);
		}
	}