A list of CallingPoint objects.

        This is the list of all subsequent calling points for the service,
        including all associated services if the service splits into multiple
        services.
979984
def subsequent_calling_points(self):
        
        calling_points = list()
        for cpl in self._subsequent_calling_point_lists:
            calling_points += cpl.calling_points
        return calling_points
443851
private <T> List<T> loadServices(final Class<T> serviceType) {
        List<T> services = new ArrayList<>();
        try {
            for (T t : ServiceLoader.load(serviceType)) {
                services.add(t);
            }
            services.sort(Comparator.comparing(o -> o.getClass().getSimpleName()));
            @SuppressWarnings("unchecked")
            final List<T> previousServices = (List<T>) servicesLoaded.putIfAbsent(serviceType, (List<Object>) services);
            return Collections.unmodifiableList(previousServices != null ? previousServices : services);
        } catch (Exception e) {
            Logger.getLogger(DefaultServiceProvider.class.getName()).log(Level.WARNING,
                                                                         "Error loading services of type " + serviceType, e);
            return services;
        }
    }
1234310
public JServiceMethod[] methods() {
        List<CServiceMethod> methods = new ArrayList<>(service.getMethodsIncludingExtended());

        CServiceMethod[] ma = methods.toArray(new CServiceMethod[methods.size()]);
        JServiceMethod[] ret = new JServiceMethod[ma.length];
        for (int i = 0; i < methods.size(); ++i) {
            ret[i] = new JServiceMethod(service, ma[i], helper);
        }
        return ret;
    }
331157
public List<ServiceMonitor> getServiceMonitors() {
        List<ServiceMonitor> serviceMonitors = new ArrayList<>();
        serviceMonitors.addAll(getDynamicServices(ServiceMonitor.class));
        return serviceMonitors;
    }
1235263
def calls(self):
        
        if self._calls is None:
            self._calls = AuthTypeCallsList(
                self._version,
                account_sid=self._solution['account_sid'],
                domain_sid=self._solution['domain_sid'],
            )
        return self._calls
127438
public void listRunningServices() {
        try {
            final List<String> formatedOutput =
                SecurityContext.executeWithSystemPermissions(new Callable<List<String>>() {
                    @Override
                    public List<String> call() throws Exception {
                        List<String> tmp = new ArrayList<String>();

                        List<ServiceReference<Domain>> listServiceReferences =
                            osgiUtilsService.listServiceReferences(Domain.class);
                        for (ServiceReference<Domain> ref : listServiceReferences) {
                            Domain service = bundleContext.getService(ref);
                            tmp.add(OutputStreamFormater.formatValues(
                                ref.getProperty(org.osgi.framework.Constants.SERVICE_PID).toString(), service
                                    .getAliveState().toString()));
                        }
                        return tmp;
                    }
                });
            for (String s : formatedOutput) {
                OutputStreamFormater.printValue(s);
            }
        } catch (ExecutionException ex) {
            ex.printStackTrace();
            System.err.println("Could not get services");
        }
    }
249068
@GET
  @Path(ServiceConstants.LIST)
  public Response list() {
    return RestUtils.call(new RestUtils.RestCallable<List<Long>>() {
      @Override
      public List<Long> call() throws Exception {
        return mJobMaster.list();
      }
    }, ServerConfiguration.global());
  }
461633
def services(self):
        """"""
        services = []
        if self._services is None:
            self.__init()
        for service in self._services:
            url = "%s/%s/%s" % (self.root, service['name'], service['type'])
            if service['type'] == "GPServer":
                services.append(GPService(url=url,
                                          securityHandler=self._securityHandler,
                                          proxy_url=self._proxy_url,
                                          proxy_port=self._proxy_port))
            elif service['type'] == "MapServer":
                services.append(MapService(url=url,
                                           securityHandler=self._securityHandler,
                                           proxy_url=self._proxy_url,
                                           proxy_port=self._proxy_port))
            elif service['type'] == "ImageServer":
                services.append(ImageService(url=url,
                                             securityHandler=self._securityHandler,
                                             proxy_url=self._proxy_url,
                                             proxy_port=self._proxy_port))
            elif service['type'] == "FeatureServer":
                if self.currentFolder == 'root':
                    serviceName = service['name']
                else:
                    serviceName = service['name'].split('/')[1]
                url = "%s/%s/%s" % (self.location, serviceName, service['type'])
                services.append(FeatureService(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_url=self._proxy_url,
                                               proxy_port=self._proxy_port))
            elif service['type'] == "GeometryServer":
                url = "%s/%s/%s" % (self.root, service['name'], service['type'])
                services.append(GeometryService(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_url=self._proxy_url,
                                               proxy_port=self._proxy_port))
            elif service['type'] == "MobileServer":
                services.append(MobileService(url=url,
                                              securityHandler=self._securityHandler,
                                              proxy_url=self._proxy_url,
                                              proxy_port=self._proxy_port))
            elif service['type'] == "NAServer":
                services.append(NetworkService(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_port=self._proxy_port,
                                               proxy_url=self._proxy_url))
            elif service['type'] == "GeocodeServer":
                services.append(GeocodeService(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_port=self._proxy_port,
                                               proxy_url=self._proxy_url))
            elif service['type'] == "GeoDataServer":
                services.append(GeoDataService(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_port=self._proxy_port,
                                               proxy_url=self._proxy_url))
            elif service['type'] == "GlobeServer":
                services.append(GlobeService(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_port=self._proxy_port,
                                               proxy_url=self._proxy_url))
            elif service['type'] == "StreamServer":
                services.append(StreamService(url=url,
                                             securityHandler=self._securityHandler,
                                             proxy_port=self._proxy_port,
                                             proxy_url=self._proxy_url))                
            elif service['type'] in ("IndexGenerator", "IndexingLauncher", "SearchServer"):
                pass
            else:
                print (service['type'], service['name'])
        return services
396830
@Override
    public List<ServiceInfo> getServiceInfos(Class serviceClass) {
        final LinkedList<ServiceInfo> result = new LinkedList<ServiceInfo>();
        for (ServiceInfo serviceInfo : services.values()) {
            if (serviceInfo.isInstanceOf(serviceClass)) {
                if (serviceInfo.isCoreService()) {
                    result.addFirst(serviceInfo);
                } else {
                    result.addLast(serviceInfo);
                }
            }
        }
        return result;
    }
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());
    }
686712
public Observable<Page<SpatialAnchorsAccountInner>> listAsync() {
        return listWithServiceResponseAsync()
            .map(new Func1<ServiceResponse<Page<SpatialAnchorsAccountInner>>, Page<SpatialAnchorsAccountInner>>() {
                @Override
                public Page<SpatialAnchorsAccountInner> call(ServiceResponse<Page<SpatialAnchorsAccountInner>> response) {
                    return response.body();
                }
            });
    }
663228
def phone_numbers(self):
        
        if self._phone_numbers is None:
            self._phone_numbers = PhoneNumberList(self._version, service_sid=self._solution['sid'], )
        return self._phone_numbers
1192299
def get_points(self):
        
        if hasattr(self, 'points'):
            points = self.crdmap.to_data(self.points)
        else:
            points = []
        return points
1213964
private void checkCallService( RequestCallInfo info )
	{
		String service = info.request.service;
		String interfaceChecksum = info.request.interfaceChecksum;

		String key = getServiceKey( info );

		if( usedServices.containsKey( key ) )
			return;

		ServiceInfo serviceInfo = new ServiceInfo( service, interfaceChecksum );
		serviceInfo.id = usedServices.size();
		usedServices.put( key, serviceInfo );
	}
723880
function () {
            var services = [], smdServices = this.smd.services;

            Object.keys(smdServices || []).forEach(function (serviceName) {
                services.push(smdServices[serviceName]);
            });

            return services;
        }
713990
def list_services(self, instance):
        
        # Server does not do pagination on listings of this resource.
        # Return an iterator anyway for similarity with other API methods
        url = '/services/{}'.format(instance)
        response = self.get_proto(path=url)
        message = rest_pb2.ListServiceInfoResponse()
        message.ParseFromString(response.content)
        services = getattr(message, 'service')
        return iter([Service(service) for service in services])
1300388
public java.util.List<ServiceDetail> getServiceDetails() {
        if (serviceDetails == null) {
            serviceDetails = new com.amazonaws.internal.SdkInternalList<ServiceDetail>();
        }
        return serviceDetails;
    }