Check the incoming list of endpoint pids (from configuration). If the list is null
or empty, return null. Otherwise return the list.

@param endpointIds
@return null (all endpoints), or trimmed list of allowed endpoints
@see #acceptFromEndpoint(String)
337852
private Collection<String> processAllowedEndpoints(Collection<String> endpointIds) {
        if (endpointIds == null || endpointIds.isEmpty())
            return null;

        return endpointIds;
    }
1291483
public final ChooseableSpecifics findChSpecificsById(
    final List<ChooseableSpecifics> pListChSpecifics,
      final Long pId) {
    for (ChooseableSpecifics chs : pListChSpecifics) {
      if (chs.getItsId().equals(pId)) {
        return chs;
      }
    }
    return null;
  }
948600
protected List<String> getEndpointUris() throws AdapterException {
        List<String> urlmap = new ArrayList<String>();
        try {
            String map = getAttributeValue(ENDPOINT_URI);
            List<String[]> urlmaparray;
            if (map==null)
                urlmaparray = new ArrayList<String[]>();
                else
                    urlmaparray = StringHelper.parseTable(map, ',', ';', 1);

            for (String[] entry : urlmaparray)
                urlmap.add(getValueSmart(entry[0], ""));
        }
        catch (Exception ex) {
            throw new AdapterException(-1, ex.getMessage(), ex);
        }
        return urlmap;
    }
640884
private List<String> getIds(ConfigurationAdmin ca, String[] pids) {
        final String methodName = "getIds(): ";
        if (pids == null) {
            return Collections.emptyList();
        }
        List<String> ids = new ArrayList<String>();
        for (String pid : pids) {
            try {
                String filter = "(" + org.osgi.framework.Constants.SERVICE_PID + "=" + pid + ")";
                Configuration[] config = ca.listConfigurations(filter);
                if (config == null) {
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, methodName + "Configuration not found for pid " + pid);
                } else {
                    if (tc.isDebugEnabled())
                        Tr.debug(tc, methodName + "Found config for " + pid);
                    String id = (String) config[0].getProperties().get("id");
                    ids.add(id);
                }
            } catch (IOException e) {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, methodName + "Configuration not found for " + pid, e);
            } catch (InvalidSyntaxException e) {
                if (tc.isDebugEnabled())
                    Tr.debug(tc, methodName + "Configuration not found for " + pid, e);
            }
        }
        return Collections.unmodifiableList(ids);
    }
204745
static List<Endpoint> of(final List<URI> uris, final DnsResolver dnsResolver) {
    final ImmutableList.Builder<Endpoint> endpoints = ImmutableList.builder();
    for (final URI uri : uris) {
      try {
        for (final InetAddress ip : dnsResolver.resolve(uri.getHost())) {
          endpoints.add(new DefaultEndpoint(uri, ip));
        }
      } catch (UnknownHostException e) {
        log.warn("Unable to resolve hostname {} into IP address", uri.getHost(), e);
      }
    }

    return endpoints.build();
  }
215596
public Set<Integer> getConnections(String endpointId) {
        return Collections.unmodifiableSet(this.entries.get(endpointId));
    }
668568
public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;

        if (bugsnag != null) {
            bugsnag.setEndpoints(endpoint, null);
        }
    }
1284350
private void setUrlParserFromEndpoints(List<String> endpoints, int port) {
    List<HostAddress> addresses = new ArrayList<>();
    for (String endpoint : endpoints) {
      HostAddress newHostAddress = new HostAddress(endpoint, port, null);
      addresses.add(newHostAddress);
    }

    synchronized (urlParser) {
      urlParser.setHostAddresses(addresses);
    }
  }
803825
private Set<Result> evaluatePids(Set<String> dsids,
                                     String pid,
                                     HttpServletRequest request,
                                     DataResponseWrapper response)
            throws ServletException {
        RequestCtx[] requests = new RequestCtx[dsids.size()];
        int ix = 0;
        for (String dsid : dsids) {
            logger.debug("Checking: {}/{}", pid, dsid);

            Map<URI, AttributeValue> actions =
                    new HashMap<URI, AttributeValue>();
            Map<URI, AttributeValue> resAttr;

            try {
                actions.put(Constants.ACTION.ID.getURI(),
                            Constants.ACTION.GET_DATASTREAM
                                    .getStringAttribute());

                resAttr = ResourceAttributes.getResources(pid);
                resAttr.put(Constants.DATASTREAM.ID.getURI(),
                            new StringAttribute(dsid));

                RequestCtx req =
                        getContextHandler()
                                .buildRequest(getSubjects(request),
                                              actions,
                                              resAttr,
                                              getEnvironment(request));

                requests[ix++] = req;
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
                throw new ServletException(e.getMessage(), e);
            }
        }

        ResponseCtx resCtx = null;
        try {
            if (logger.isDebugEnabled()) {
                logger.debug("Number of requests: " + requests.length);
            }

            resCtx =
                    getContextHandler().evaluateBatch(requests);

        } catch (MelcoeXacmlException pe) {
            throw new ServletException("Error evaluating pids: "
                    + pe.getMessage(), pe);
        }

        @SuppressWarnings("unchecked")
        Set<Result> results = resCtx.getResults();

        return results;
    }
734346
public Point getPoint(String id) {
        for (Point point : points)
            if (id.equals(point.getId()))
                return point;
        return null;
    }
902925
private static Endpoint selectFirstConnected(final List<Endpoint> endpoints) {
        for (Endpoint endpoint : endpoints) {
            if (endpoint.isState(LifecycleState.CONNECTED) && endpoint.isFree()) {
                return endpoint;
            }
        }
        return null;
    }
1125130
public Collection<EndpointInfo> getEndpointInfos() {

        ArrayList<EndpointInfo> values = new ArrayList<EndpointInfo>();

        Iterator<String> it = getEndpointNames().iterator();
        // for each endpoint name, iterate over it's list of endpoints and add to values
        while (it.hasNext()) {
            List<EndpointInfo> list = endpointInfoMap.get(it.next());
            for (int i = 0; i < list.size(); i++) {
                values.add(list.get(i));
            }
        }
        return Collections.unmodifiableCollection(values);
        //return Collections.unmodifiableCollection(endpointInfoMap.values());
    }
1190319
protected final void setEndpoints(Iterable<Endpoint> endpoints) {
        final List<Endpoint> oldEndpoints = this.endpoints;
        final List<Endpoint> newEndpoints = ImmutableList.sortedCopyOf(endpoints);

        if (oldEndpoints.equals(newEndpoints)) {
            return;
        }

        endpointsLock.lock();
        try {
            this.endpoints = newEndpoints;
        } finally {
            endpointsLock.unlock();
        }

        notifyListeners(newEndpoints);
        completeInitialEndpointsFuture(newEndpoints);
    }
230853
def my_shared_endpoint_list(endpoint_id):
    
    client = get_client()
    ep_iterator = client.my_shared_endpoint_list(endpoint_id)

    formatted_print(ep_iterator, fields=ENDPOINT_LIST_FIELDS)
5422
public void setConfigurationIds(java.util.Collection<String> configurationIds) {
        if (configurationIds == null) {
            this.configurationIds = null;
            return;
        }

        this.configurationIds = new java.util.ArrayList<String>(configurationIds);
    }
319257
public Set<Integer> removeConnections(String endpointId) {
        Set<Integer> removed = this.entries.removeAll(endpointId);
        if (!removed.isEmpty() && log.isDebugEnabled()) {
            log.debug("Call " + getCallIdHex() + " unregistered connections " + Arrays.toString(convertToHex(removed)) + " from endpoint " + endpointId);
        }
        return removed;
    }
160278
Point getPointForID(int id) {
        for (int i = 0; i < pointCount; i++) {
            if (id == -1 || points[i].id == id) {
                return points[i];
            }
        }
        return null;
    }