/*
(non-Javadoc)

@see com.ibm.ws.sib.processor.impl.interfaces.DestinationHandler#getAllPubSubOutputHandlers()
322162
public HashMap<SIBUuid8, PubSubOutputHandler> getAllPubSubOutputHandlers()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getAllPubSubOutputHandlers");

        _pubsubOutputHandlerLockManager.lock();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getAllPubSubOutputHandlers", _pubsubOutputHandlers);

        return _pubsubOutputHandlers;
    }
779219
@Override
    public synchronized PubSubOutputHandler createPubSubOutputHandler(Neighbour neighbour)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "createPubSubOutputHandler", new Object[] { neighbour });

        PubSubOutputHandler handler =
                        _pubSubRealization.createPubSubOutputHandler(neighbour);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "createPubSubOutputHandler", handler);

        return handler;
    }
47428
public List<PaymentProtocol.Output> getOutputs() {
        List<PaymentProtocol.Output> outputs = new ArrayList<>(paymentDetails.getOutputsCount());
        for (Protos.Output output : paymentDetails.getOutputsList()) {
            Coin amount = output.hasAmount() ? Coin.valueOf(output.getAmount()) : null;
            outputs.add(new PaymentProtocol.Output(amount, output.getScript().toByteArray()));
        }
        return outputs;
    }
658083
public java.util.List<SuspendedProcess> getSuspendedProcesses() {
        if (suspendedProcesses == null) {
            suspendedProcesses = new com.amazonaws.internal.SdkInternalList<SuspendedProcess>();
        }
        return suspendedProcesses;
    }
989681
@Override
    public OutputHandler choosePtoPOutputHandler(SIBUuid8 fixedMEUuid,
                                                 SIBUuid8 preferredMEUuid,
                                                 boolean localMessage,
                                                 boolean forcePut,
                                                 HashSet<SIBUuid8> scopedMEs)
                    throws
                    SIRollbackException,
                    SIConnectionLostException,
                    SIResourceException,
                    SIErrorException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "choosePtoPOutputHandler", new Object[] { fixedMEUuid,
                                                                     preferredMEUuid,
                                                                     localMessage,
                                                                     forcePut,
                                                                     scopedMEs });

        // We're an alias (or foreign destination) so we should never be called with a scoped ME set
        if (scopedMEs != null)
        {
            SIMPErrorException e = new SIMPErrorException("Alias called with scoped ME set");

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            {
                SibTr.exception(tc, e);
            }

            e.setExceptionReason(SIRCConstants.SIRC0901_INTERNAL_MESSAGING_ERROR);
            e.setExceptionInserts(new String[] { "com.ibm.ws.sib.processor.impl.ProducerSessionImpl.handleMessage",
                                                "1:290:1.67.1.22",
                                                SIMPUtils.getStackTrace(e) });

            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "choosePtoPOutputHandlers", e);

            throw e;
        }

        // Look to the resolved destination to choose an output handler as the
        // alias destination doesnt store any messages
        OutputHandler result = _targetDestinationHandler.choosePtoPOutputHandler(fixedMEUuid, preferredMEUuid, localMessage, false, null);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "choosePtoPOutputHandler", result);

        return result;
    }
948291
@Override
    public OutputHandler choosePtoPOutputHandler(SIBUuid8 fixedMEUuid,
                                                 SIBUuid8 preferredMEUuid,
                                                 boolean localMessage,
                                                 boolean forcePut,
                                                 HashSet<SIBUuid8> scopedMEs)
                    throws
                    SIRollbackException,
                    SIConnectionLostException,
                    SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(
                        tc,
                        "choosePtoPOutputHandler",
                        new Object[] { fixedMEUuid,
                                      preferredMEUuid,
                                      Boolean.valueOf(localMessage),
                                      Boolean.valueOf(forcePut),
                                      scopedMEs });

        OutputHandler result =
                        _protoRealization.
                                        choosePtoPOutputHandler(fixedMEUuid,
                                                                preferredMEUuid,
                                                                localMessage,
                                                                forcePut,
                                                                _singleServer, // Are we running in a single server environment?
                                                                scopedMEs);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "choosePtoPOutputHandler", result);

        return result;
    }
686227
@Override
    public List getSubscriptionList()
                    throws
                    SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getSubscriptionList");

        List subscriptions = _pubSubRealization.getSubscriptionList();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getSubscriptionList", subscriptions);
        return subscriptions;
    }
119699
public OutputHandler choosePtoPOutputHandler(SIBUuid12 linkUuid) 
    throws SIResourceException 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "choosePtoPOutputHandler", linkUuid);      
      
    OutputHandler result = null;
    LinkSelection s = null;
    
    if (isLocalMsgsItemStream())
    {
      result = (OutputHandler) getLocalPtoPConsumerManager();
      result.setWLMGuess(false);
    }
    else
    {
      // Pick an ME to send the message to.
      s = _localisationManager.getTRMFacade().chooseLink(linkUuid);      
      
      //If the link is not available in WLM, we either continue putting the
      //messages to where we think the bridge is, but marking them as 
      //guesses, or if we dont know where the bridge is, we put them
      //to the uuid SIMPConstants.UNKNOWN_UUID
      if (s == null)
      {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          SibTr.debug(tc, "Link not available in WLM");

        //lastKnownMEOutputHandler should only ever be null if no outputhandlers exist
        //for the link.  In this case, one should be created.  As TRM/WLM cannot 
        //provide one, a temporary localisation is set up to hold the messages 
        //until TRM can provide a proper response.
        if (_lastKnownMEOutputHandler == null)
        {
          SIBUuid8 localisingME = new SIBUuid8(SIMPConstants.UNKNOWN_UUID);
             
          updateLocalisationSet(localisingME, localisingME);
        }
        
        result = _lastKnownMEOutputHandler;
        result.setWLMGuess(true);
      }
      else
      {
        SIBUuid8 choiceUuid = s.getInboundMeUuid();
        SIBUuid8 routingUuid = s.getOutboundMeUuid();
 
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          SibTr.debug(tc, "InboundMeUuid is " + choiceUuid + " OutboundMeUuid is  " + routingUuid);
        
        if (choiceUuid == null)
        {
          //In the MQLink case there is no inboundMeUuid, so send the message
          //to the outboundMeUuid
          choiceUuid = s.getOutboundMeUuid();
        }

        result = getQueuePointOutputHandler(choiceUuid);
        
  
        if (result == null)
        {        
          updateLocalisationSet(choiceUuid, routingUuid);
  
          result = getQueuePointOutputHandler(choiceUuid);
        }
        result.setWLMGuess(false);
        
        if (routingUuid != null)
        {
          // If this is the ME hosting the link then send to 
          // the foreign ME of the link (choiceUuid) 
          // Otherwise send to the ME hosting the link in this bus
          if(routingUuid.equals( _messageProcessor.getMessagingEngineUuid() ))
          {
            routingUuid = choiceUuid;
          }
          // Currently Links only have one queue point so preferLocal is always true.
          // When multiple links are introduced it will be possible for the result here
          // to be a ConsumerDispatcher and therefore this cast will fail.
          ((PtoPOutputHandler)result).updateRoutingCellule(routingUuid);
        }
      }
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "choosePtoPOutputHandler", result);

    return result;   
  }
1220982
@Override
    public synchronized Collection<IOutput> outputs()
    {
        if (null == outputs)
        {
            outputs = new ArrayList<IOutput>();
            final Iterator<Output> processInputs = service.getProcess().getOutputs().iterator();
            while (processInputs.hasNext())
            {
                outputs.add(new IOutput()
                {
                    private Output owlOutput = processInputs.next();

                    @Override
                    public String name()
                    {
                        return owlOutput.getName();
                    }

                    @Override
                    public ISemanticIdentifier getSemanticAnnotation()
                    {
                        //return new SemanticIdentifier(owlOutput.getType().getURI());
                        return new SemanticIdentifier(owlOutput.getParamType().getURI());
                    }
                });
            }
        }

        return outputs;
    }
1094191
public List<PublicRenderParameterType<PortletDescriptor>> getAllPublicRenderParameter()
   {
      List<PublicRenderParameterType<PortletDescriptor>> list = new ArrayList<PublicRenderParameterType<PortletDescriptor>>();
      List<Node> nodeList = model.get("public-render-parameter");
      for(Node node: nodeList)
      {
         PublicRenderParameterType<PortletDescriptor>  type = new PublicRenderParameterTypeImpl<PortletDescriptor>(this, "public-render-parameter", model, node);
         list.add(type);
      }
      return list;
   }
795172
public java.util.List<String> getJobFlowIds() {
        if (jobFlowIds == null) {
            jobFlowIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return jobFlowIds;
    }
1364281
@Override
    public OutputHandler getQueuePointOutputHandler(SIBUuid8 meUuid)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getQueuePointOutputHandler", new Object[] { meUuid, this });

        OutputHandler result =
                        _localisationManager.
                                        getQueuePointOutputHandler(meUuid);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getQueuePointOutputHandler", result);
        return result;
    }
717061
public List<EntryPoint> retrieveAllExternalEntryPoints() {
		
		final List<EntryPoint> entryPoints = new ArrayList<EntryPoint>();
		
		final Map<RequestMappingInfo, HandlerMethod> allUrls = handlerMapping.getHandlerMethods();
		
		for (RequestMappingInfo mappingInfo : allUrls.keySet()) {
			final HandlerMethod handlerMethod = allUrls.get(mappingInfo);
			
			// If no pattern is defined, we do not add to the list
			if (mappingInfo.getPatternsCondition() != null && ExternalEntryPointHelper.isAnEntryPoint(handlerMethod.getMethod(), scanEntryPointAnnotation)) {
				final EntryPoint entryPoint = new EntryPoint();
				entryPoint.setParameters(new ArrayList<EntryPointParameter>());
				
				// All the url's this method can handle
				entryPoint.setUrls(mappingInfo.getPatternsCondition().getPatterns());
				
				// If there specified methods, we add them to the returned object
				if (mappingInfo.getMethodsCondition() != null) { 
					entryPoint.setRequestMethods(mappingInfo.getMethodsCondition().getMethods());
				}
				
				final Method method = handlerMethod.getMethod();
				entryPoint.setMethodName(method.getName());
				entryPoint.setMethodDecorationName(ExternalEntryPointHelper.getEntryPointDecoratedName(method, scanEntryPointAnnotation));
				entryPoint.setType(method.getDeclaringClass());
				entryPoint.setResponseType(method.getReturnType());
				
				// Get the defined parameter names, they might be overwritten by a @RequestParam
				final String[] parameterNames = nameDiscover.getParameterNames(method);
				
				// Consolidated blacklist, if might have details on @ExternalEntryPoint
				final Set<Class<?>> consolidatedTypeBlacklist = ExternalEntryPointHelper.getConsolidatedTypeBlacklist(paramTypesBlacklist, method, scanEntryPointAnnotation);
				final Set<String> consolidatedNameBlacklist = ExternalEntryPointHelper.getConsolidatedNameBlacklist(paramNamesBlacklist, method, scanEntryPointAnnotation);
				
				// Time to retrieve all the parameters
				for (MethodParameter methodParameter : handlerMethod.getMethodParameters()) {
					computeInputParatemeter(entryPoint, parameterNames, consolidatedTypeBlacklist, consolidatedNameBlacklist, methodParameter);
					
				}
				
				entryPoints.add(entryPoint);
			}
			
		}
		
		return entryPoints;
	}
905518
public Set<String> getOutputDirectories() {
		Set<String> outputDirectories = Sets.newLinkedHashSet();
		if (isUseOutputPerSourceFolder()) {
			for (SourceMapping mapping : getSourceMappings()) {
				outputDirectories.add(getOutputDirectory(mapping.getSourceFolder()));
			}
		} else {
			outputDirectories.add(getOutputDirectory());
		}
		return outputDirectories;
	}
1008048
public PubSubRealization getPubSubRealization()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "getPubSubRealization");
            SibTr.exit(tc, "getPubSubRealization", _pubSubRealization);
        }
        return _pubSubRealization;
    }
113074
public ArrayList getAllPubSubOutputHandlerMatchTargets()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getAllPubSubOutputHandlerMatchTargets");

    ArrayList outputHandlerList;

    // Get from the HashMap, with synch, there may be other accessors
    synchronized(_targets)
    {
      outputHandlerList = new ArrayList(_targets.size());
      Iterator itr = _targets.keySet().iterator();

      while (itr.hasNext())
      {
        Object key = itr.next();

        if (key instanceof ControllableProxySubscription)
          outputHandlerList.add(
            ((ControllableProxySubscription) key).getOutputHandler());

      }
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(
        tc,
        "getAllPubSubOutputHandlerMatchTargets",
        outputHandlerList);

    return outputHandlerList;
  }
698338
public HashMap<SIBUuid8, PubSubOutputHandler> cloneAllPubSubOutputHandlers()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "cloneAllPubSubOutputHandlers");

        HashMap<SIBUuid8, PubSubOutputHandler> clone = null;
        try
        {
            _pubsubOutputHandlerLockManager.lock();
            clone = (HashMap<SIBUuid8, PubSubOutputHandler>) _pubsubOutputHandlers.clone();
        } finally
        {
            _pubsubOutputHandlerLockManager.unlock();
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "cloneAllPubSubOutputHandlers", clone);
        return clone;
    }