Retrieve the LimitData object the middleware will use for
        getting the limits.  This implementation returns a
        RemoteLimitData instance that can access the LimitData stored
        in the RemoteControlDaemon process.
509486
def get_limits(self):
        

        # Set one up if we don't already have it
        if not self.remote_limits:
            self.remote_limits = RemoteLimitData(self.remote)
        return self.remote_limits
1091540
private function getLimit(Parameters $parameters, int $maxLimit = null): int
    {
        $maxLimit = $maxLimit ?? config('json-api.defaults.max-limit', 50);
        $limit = $parameters->getLimit($maxLimit);

        return $limit ?? $maxLimit;
    }
443260
function getRangeRemote(start, limit, store) {
      // Request for data calling listRemote function
      store.listRemote(function() {
        // Get store data by range
        StoreMemory.getRange(start, limit, null, store);
        // Trigger user callback once data has been retrieved
        vcomet.triggerCallback("onGetRangeRemote", store);
      });
    }
88494
public function getLimit()
    {
        $limit = $this->request->get('!limit');

        if (is_null($limit) && !is_null($this->collection->option('limit'))) {
            $limit = $this->collection->option('limit');
        }

        return $limit;
    }
368109
protected function _getLimit($key = null, $default = null) {
		$result = (int)$default;
		if (empty($key)) {
			return $result;
		}

		$data = $this->getConfig('LdapSync.Limits.' . $key);
		if (($data === null) || !is_int($data)) {
			return $result;
		}

		$data = (int)$data;
		if ($data < 0) {
			return $result;
		}

		return $data;
	}
493821
def getIRData(self):
        '''
        

        '''     
        if self.hasproxy():
            self.lock.acquire()
            ir = self.ir
            self.lock.release()
            return ir

        return None
390650
public FutureData<Limit> getLimit(String identity, String service) {
        FutureData<Limit> future = new FutureData<>();
        URI uri = newParams().forURL(config.newAPIEndpointURI(IDENTITY + "/" + identity + "/limit/" + service));
        Request request = config.http().
                GET(uri, new PageReader(newRequestCallback(future, new Limit(), config)));
        performRequest(future, request);
        return future;
    }
966436
public static nslimitsessions[] get(nitro_service service, nslimitsessions_args args) throws Exception{
		nslimitsessions obj = new nslimitsessions();
		options option = new options();
		option.set_args(nitro_util.object_to_string_withoutquotes(args));
		nslimitsessions[] response = (nslimitsessions[])obj.get_resources(service, option);
		return response;
	}
1162529
public static nslimitselector[] get(nitro_service service) throws Exception{
		nslimitselector obj = new nslimitselector();
		nslimitselector[] response = (nslimitselector[])obj.get_resources(service);
		return response;
	}
488111
def limit(self, limit):
    
    params = join_params(self.parameters, {"limit": limit})

    return self.__class__(**params)
1021675
public function getData()
    {
        $limit = $this->getLimit();
        $this->setHeaders();
        $page  = $this->getPage();
        if ($page > 0) {
            $page-=1;
        }
        return $this->getDataSource()->limit($limit)->offset($limit * $page)->getAll();
    }
228882
def max_send_data_size(self):
        
        with self.lock:
            if self.device is None:
                raise IOError(errno.ENODEV, os.strerror(errno.ENODEV))
            else:
                return self.device.get_max_send_data_size(self.target)
386692
public function getLimit()
    {
        if (!is_null($this->suppliedLimit)) {
            return $this->suppliedLimit;
        } elseif (!is_null($this->entityLimit)) {
            return $this->entityLimit;
        }
        return false;
    }
1067361
public RateLimiter getRateLimiter()
    {
        double currentThroughput = DatabaseDescriptor.getCompactionThroughputMbPerSec() * 1024.0 * 1024.0;
        // if throughput is set to 0, throttling is disabled
        if (currentThroughput == 0 || StorageService.instance.isBootstrapMode())
            currentThroughput = Double.MAX_VALUE;
        if (compactionRateLimiter.getRate() != currentThroughput)
            compactionRateLimiter.setRate(currentThroughput);
        return compactionRateLimiter;
    }
945544
@SuppressWarnings("unchecked")
    @Override
    public M getData() throws NotAvailableException {
        try {
            return (M) cloneDataBuilder().build();
        } catch (Exception ex) {
            throw new NotAvailableException("Data", new CouldNotPerformException("Could not build message!", ex));
        }
    }
353392
public static nslimitidentifier[] get(nitro_service service, String limitidentifier[]) throws Exception{
		if (limitidentifier !=null && limitidentifier.length>0) {
			nslimitidentifier response[] = new nslimitidentifier[limitidentifier.length];
			nslimitidentifier obj[] = new nslimitidentifier[limitidentifier.length];
			for (int i=0;i<limitidentifier.length;i++) {
				obj[i] = new nslimitidentifier();
				obj[i].set_limitidentifier(limitidentifier[i]);
				response[i] = (nslimitidentifier) obj[i].get_resource(service);
			}
			return response;
		}
		return null;
	}
972853
static UserLimits getLimitsFromUserAccount(HTTPServerConfig config, String username, String password) {
    Objects.requireNonNull(username);
    Objects.requireNonNull(password);
    String token = cache.getUnchecked(new Account(username, password));
    return getLimitsFromToken(config, token);
  }