Gets the provider endpoints
181802.2

@return The provider endpoints
@see com.ibm.websphere.sib.api.jms.JmsConnectionFactory#getProviderEndpoints
548137
@Override
    public String getProviderEndpoints() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getProviderEndpoints");
        String providerEndpoints = jcaConnectionFactory.getProviderEndpoints();
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getProviderEndpoints", providerEndpoints);
        return providerEndpoints;
    }
871632
@Override
    public List<Class<? extends AbstractResource>> getEndpoints() {
        List<Class<? extends AbstractResource>> result = new LinkedList<>();

        result.add(AuditResources.class);
        result.add(AuthResources.class);
        result.add(AuthResourcesV2.class);
        result.add(AlertResources.class);
        result.add(AnnotationResources.class);
        result.add(CollectionResources.class);
        result.add(DashboardResources.class);
        result.add(HistoryResources.class);
        result.add(ManagementResources.class);
        result.add(MetricResources.class);
        result.add(NamespaceResources.class);
        result.add(UserResources.class);
        result.add(DiscoveryResources.class);
        return result;
    }
438108
@Override
    public Map<String, String> getWebserviceEndpointProperties() {
        return webserviceEndpointProperties == null ? null : webserviceEndpointProperties.getAttributes();
    }
840442
public java.util.List<VpcEndpoint> getVpcEndpoints() {
        if (vpcEndpoints == null) {
            vpcEndpoints = new com.amazonaws.internal.SdkInternalList<VpcEndpoint>();
        }
        return vpcEndpoints;
    }
448618
public Set<String> getAllHandlers(EndpointConfig config) {
      Set<String> set = new HashSet<String>();
      if (config != null) {
         for (UnifiedHandlerChainMetaData uhcmd : config.getPreHandlerChains()) {
            for (UnifiedHandlerMetaData uhmd : uhcmd.getHandlers()) {
               set.add(uhmd.getHandlerClass());
            }
         }
         for (UnifiedHandlerChainMetaData uhcmd : config.getPostHandlerChains()) {
            for (UnifiedHandlerMetaData uhmd : uhcmd.getHandlers()) {
               set.add(uhmd.getHandlerClass());
            }
         }
      }
      return set;
   }
209057
public String[] getEndpointInfo(InetAddress endpoint)
    {
        String[] rawEndpointInfo = getRawEndpointInfo(endpoint);
        if (rawEndpointInfo == null)
            throw new RuntimeException("Unknown host " + endpoint + " with no default configured");
        return rawEndpointInfo;
    }
467166
public List<JmsConnectionFactoryType<WebFragmentDescriptor>> getAllJmsConnectionFactory()
   {
      List<JmsConnectionFactoryType<WebFragmentDescriptor>> list = new ArrayList<JmsConnectionFactoryType<WebFragmentDescriptor>>();
      List<Node> nodeList = model.get("jms-connection-factory");
      for(Node node: nodeList)
      {
         JmsConnectionFactoryType<WebFragmentDescriptor>  type = new JmsConnectionFactoryTypeImpl<WebFragmentDescriptor>(this, "jms-connection-factory", model, node);
         list.add(type);
      }
      return list;
   }
1090071
static SLF4JServiceProvider getProvider() {
        if (INITIALIZATION_STATE == UNINITIALIZED) {
            synchronized (LoggerFactory.class) {
                if (INITIALIZATION_STATE == UNINITIALIZED) {
                    INITIALIZATION_STATE = ONGOING_INITIALIZATION;
                    performInitialization();
                }
            }
        }
        switch (INITIALIZATION_STATE) {
        case SUCCESSFUL_INITIALIZATION:
            return PROVIDER;
        case NOP_FALLBACK_INITIALIZATION:
            return NOP_FALLBACK_FACTORY;
        case FAILED_INITIALIZATION:
            throw new IllegalStateException(UNSUCCESSFUL_INIT_MSG);
        case ONGOING_INITIALIZATION:
            // support re-entrant behavior.
            // See also http://jira.qos.ch/browse/SLF4J-97
            return SUBST_PROVIDER;
        }
        throw new IllegalStateException("Unreachable code");
    }
587042
public java.util.List<String> getBaseEndpointDnsNames() {
        if (baseEndpointDnsNames == null) {
            baseEndpointDnsNames = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return baseEndpointDnsNames;
    }
725864
public java.lang.String getProvider() {
    java.lang.Object ref = provider_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      provider_ = s;
      return s;
    }
  }
1340578
public ApiResponse<ApiEndpointsSuccess> getApiEndpointsWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getApiEndpointsValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<ApiEndpointsSuccess>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
131898
@Pure
	<CT extends RoadConnection> CT getEndPoint(Class<CT> connectionClass) {
		final StandardRoadConnection connection = this.lastConnection;
		if (connection == null) {
			return null;
		}
		if (connectionClass.isAssignableFrom(StandardRoadConnection.class)) {
			return connectionClass.cast(connection);
		}
		if (connectionClass.isAssignableFrom(RoadConnectionWithArrivalSegment.class)) {
			return connectionClass.cast(new RoadConnectionWithArrivalSegment(connection, this, false));
		}
		throw new IllegalArgumentException("unsupported RoadConnection class");  //$NON-NLS-1$
	}
740603
public List<JmsDestinationType<WebAppType<T>>> getAllJmsDestination()
   {
      List<JmsDestinationType<WebAppType<T>>> list = new ArrayList<JmsDestinationType<WebAppType<T>>>();
      List<Node> nodeList = childNode.get("jms-destination");
      for(Node node: nodeList)
      {
         JmsDestinationType<WebAppType<T>>  type = new JmsDestinationTypeImpl<WebAppType<T>>(this, "jms-destination", childNode, node);
         list.add(type);
      }
      return list;
   }
430634
@PreAuthorize("hasRole(@configHolder.getSuperAdminRoleName())")
    public Set<RequestMappingInfo> getEndpoints(RequestMappingHandlerMapping requestMappingHandlerMapping) {

        if (requestMappingHandlerMapping.getHandlerMethods() != null) {
            return requestMappingHandlerMapping.getHandlerMethods().keySet();
        }

        return null;
    }
465271
@ConfigurationProperty(displayMessageKey = "ENDPOINT_DISPLAY",
            helpMessageKey = "ENDPOINT_HELP",
            confidential = false, order = 1, required = true)
    public String getEndpoint() {
        return endpoint;
    }
218280
private ImmutableList<EndPoint> getEndPoints() {
        ImmutableList<EndPoint> endPoints = _endPoints;
        if (endPoints == null) {
            boolean locked = false;
            try {
                long timeout = System.currentTimeMillis() + 10;

                locked = _lock.tryLock(10, TimeUnit.MILLISECONDS);
                if (locked) {
                    endPoints = _endPoints;
                    long waitTime = timeout - System.currentTimeMillis();
                    if (endPoints == null && waitTime > 0) {
                        _endpointsAvailable.await(waitTime, TimeUnit.MILLISECONDS);
                        endPoints = _endPoints;
                    }
                }
            } catch (InterruptedException e) {
                // ignore
            } finally {
                if (locked) {
                    _lock.unlock();
                }
            }

            if (endPoints == null) {
                // Took too long waiting for the background to re-populate endpoints, just fetch from the source
                endPoints = getEndPointsFromHostDiscovery();
            }
        }
        
        return endPoints;
    }
974378
private Endpoint getEndpoint(String serviceName) {
        Endpoint cachedEndpoint = endpointCache.get(serviceName);

        if (cachedEndpoint == null) {
            cachedEndpoint = computeEndpoint(serviceName);
            if (cachedEndpoint == null) {
                return null;
            }
        }

        endpointCache.put(serviceName, cachedEndpoint);
        return cachedEndpoint;
    }