.gitignore 0000644 00000000232 15174273455 0006546 0 ustar 00 .DS_Store
phpunit.xml
composer.phar
composer.lock
composer-test.lock
vendor/
build/artifacts/
artifacts/
.idea
.metadata
coverage.xml
src/Jison/Parser.js
.travis.yml 0000644 00000000443 15174273455 0006673 0 ustar 00 language: php
php:
- '5.5.38'
- '5.6.25'
sudo: required
dist: trusty
install:
- pecl install grpc
- composer install
script:
- vendor/bin/phpunit --coverage-clover=coverage.xml
- vendor/bin/phpcs -l --standard=PSR2 src/
after_success:
- bash <(curl -s https://codecov.io/bash)
CONTRIBUTING.md 0000644 00000002654 15174273455 0007021 0 ustar 00 Want to contribute? Great! First, read this page (including the small print at the end).
### Before you contribute
Before we can use your code, you must sign the
[Google Individual Contributor License Agreement]
(https://cla.developers.google.com/about/google-individual)
(CLA), which you can do online. The CLA is necessary mainly because you own the
copyright to your changes, even after your contribution becomes part of our
codebase, so we need your permission to use and distribute your code. We also
need to be sure of various other things—for instance that you'll tell us if you
know that your code infringes on other people's patents. You don't have to sign
the CLA until after you've submitted your code for review and a member has
approved it, but you must do it before we can put your code into our codebase.
Before you start working on a larger contribution, you should get in touch with
us first through the issue tracker with your idea so that we can help out and
possibly guide you. Coordinating up front makes it much easier to avoid
frustration later on.
### Code reviews
All submissions, including submissions by project members, require review. We
use Github pull requests for this purpose.
### The small print
Contributions made by corporations are covered by a different agreement than
the one above, the
[Software Grant and Corporate Contributor License Agreement]
(https://cla.developers.google.com/about/google-corporate).
LICENSE 0000644 00000002700 15174273455 0005565 0 ustar 00 Copyright 2016, Google Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
README.md 0000644 00000003332 15174273455 0006041 0 ustar 00 Google API Extensions for PHP
=================================
[]
(https://travis-ci.org/googleapis/gax-php)
[]
(https://codecov.io/github/googleapis/gax-php)
- [Documentation] (http://googleapis.github.io/gax-php/phpdoc)
Google API Extensions for PHP (gax-php) is a set of modules which aids
the development of APIs for clients based on [gRPC][] and Google API
conventions.
Application code will rarely need to use most of the classes within this library
directly, but code generated automatically from the API definition files in
[Google APIs][] can use services such as page streaming and retry to
provide a more convenient and idiomatic API surface to callers.
[gRPC]: http://grpc.io
[Google APIs]: https://github.com/googleapis/googleapis/
PHP Versions
----------------
gax-php currently requires PHP 5.5 or higher.
Contributing
------------
Contributions to this library are always welcome and highly encouraged.
See the [CONTRIBUTING][] documentation for more information on how to get started.
[CONTRIBUTING]: https://github.com/googleapis/gax-php/blob/master/CONTRIBUTING.md
Versioning
----------
This library follows [Semantic Versioning][].
It is currently in major version zero (``0.y.z``), which means that anything
may change at any time and the public API should not be considered
stable.
[Semantic Versioning]: http://semver.org/
Repository Structure
-------
All code lives under src/ and is contained in the `Google\GAX` namespace.
License
-------
BSD - See [LICENSE][] for more information.
[LICENSE]: https://github.com/googleapis/gax-php/blob/master/LICENSE
composer.json 0000644 00000001201 15174273455 0007275 0 ustar 00 {
"name": "google/gax",
"type": "library",
"description": "Google API Extensions for PHP",
"keywords": ["google"],
"homepage": "https://github.com/googleapis/gax-php",
"license": "BSD-3-Clause",
"require": {
"php": ">=5.5",
"google/auth": "v0.10",
"grpc/grpc": "v1.0.0"
},
"require-dev": {
"phpunit/phpunit": "4.8.*",
"squizlabs/php_codesniffer": "2.*",
"phpdocumentor/phpdocumentor": "*"
},
"autoload": {
"psr-4": {
"Google\\GAX\\":"src/"
},
"classmap": ["src/generated", "src/generated/well-known-types"]
}
}
phpunit.xml.dist 0000644 00000000633 15174273455 0007736 0 ustar 00
tests
src
src/generated
src/AgentHeaderDescriptor.php 0000644 00000007062 15174273455 0012274 0 ustar 00 clientName = $headerInfo['clientName'];
$this->clientVersion = $headerInfo['clientVersion'];
$this->codeGenName = $headerInfo['codeGenName'];
$this->codeGenVersion = $headerInfo['codeGenVersion'];
$this->gaxVersion = $headerInfo['gaxVersion'];
$this->phpVersion = $headerInfo['phpVersion'];
}
/**
* Returns an associative array that contains GAPIC header metadata.
*/
public function getHeader()
{
return [self::AGENT_HEADER_KEY => ["$this->clientName/$this->clientVersion;".
"$this->codeGenName/$this->codeGenVersion;gax/$this->gaxVersion;".
"php/$this->phpVersion"]];
}
private static function validate($descriptor)
{
$requiredFields = ['clientName', 'clientVersion', 'codeGenName',
'codeGenVersion', 'gaxVersion', 'phpVersion'];
foreach ($requiredFields as $field) {
if (empty($descriptor[$field])) {
throw new InvalidArgumentException(
"$field is required for AgentHeaderDescriptor"
);
}
}
}
}
src/ApiCallable.php 0000644 00000017504 15174273455 0010221 0 ustar 00 getBackoffSettings();
// Initialize retry parameters
$delayMult = $backoffSettings->getRetryDelayMultiplier();
$maxDelayMillis = $backoffSettings->getMaxRetryDelayMillis();
$timeoutMult = $backoffSettings->getRpcTimeoutMultiplier();
$maxTimeoutMillis = $backoffSettings->getMaxRpcTimeoutMillis();
$totalTimeoutMillis = $backoffSettings->getTotalTimeoutMillis();
$delayMillis = $backoffSettings->getInitialRetryDelayMillis();
$timeoutMillis = $backoffSettings->getInitialRpcTimeoutMillis();
$currentTimeMillis = $timeFuncMillis();
$deadlineMillis = $currentTimeMillis + $totalTimeoutMillis;
while ($currentTimeMillis < $deadlineMillis) {
$nextApiCall = self::setTimeout($apiCall, $timeoutMillis);
try {
return call_user_func_array($nextApiCall, func_get_args());
} catch (ApiException $e) {
if (!in_array($e->getCode(), $retrySettings->getRetryableCodes())) {
throw $e;
}
} catch (Exception $e) {
throw $e;
}
// Don't sleep if the failure was a timeout
if ($e->getCode() != Grpc\STATUS_DEADLINE_EXCEEDED) {
usleep($delayMillis * 1000);
}
$currentTimeMillis = $timeFuncMillis();
$delayMillis = min($delayMillis * $delayMult, $maxDelayMillis);
$timeoutMillis = min(
$timeoutMillis * $timeoutMult,
$maxTimeoutMillis,
$deadlineMillis - $currentTimeMillis
);
}
throw new ApiException("Retry total timeout exceeded.", Grpc\STATUS_DEADLINE_EXCEEDED);
};
return $inner;
}
private static function setPageStreaming($callable, $pageStreamingDescriptor)
{
$inner = function () use ($callable, $pageStreamingDescriptor) {
return new PagedListResponse(func_get_args(), $callable, $pageStreamingDescriptor);
};
return $inner;
}
private static function setCustomHeader($callable, $headerDescriptor)
{
$inner = function () use ($callable, $headerDescriptor) {
$params = func_get_args();
if (count($params) != self::GRPC_CALLABLE_PARAM_COUNT ||
!is_array($params[self::GRPC_CALLABLE_METADATA_INDEX])) {
throw new InvalidArgumentException('Metadata argument is not found.');
} else {
$metadata = $params[self::GRPC_CALLABLE_METADATA_INDEX];
$headers = $headerDescriptor->getHeader();
$params[self::GRPC_CALLABLE_METADATA_INDEX] = array_merge($headers, $metadata);
return call_user_func_array($callable, $params);
}
};
return $inner;
}
/**
* @param Grpc\BaseStub $stub the gRPC stub to make calls through.
* @param string $methodName the method name on the stub to call.
* @param Google\GAX\CallSettings $settings the call settings to use for this call.
* @param array $options {
* Optional.
* @type Google\GAX\PageStreamingDescriptor $pageStreamingDescriptor
* the descriptor used for page-streaming.
* @type Google\GAX\AgentHeaderDescriptor $headerDescriptor
* the descriptor used for creating GAPIC header.
* }
*/
public static function createApiCall($stub, $methodName, CallSettings $settings, $options = [])
{
$apiCall = function () use ($stub, $methodName) {
list($response, $status) =
call_user_func_array(array($stub, $methodName), func_get_args())->wait();
if ($status->code == Grpc\STATUS_OK) {
return $response;
} else {
throw new ApiException($status->details, $status->code);
}
};
$retrySettings = $settings->getRetrySettings();
if (!is_null($retrySettings) && !is_null($retrySettings->getRetryableCodes())) {
$timeFuncMillis = null;
if (array_key_exists('timeFuncMillis', $options)) {
$timeFuncMillis = $options['timeFuncMillis'];
}
$apiCall = self::setRetry($apiCall, $settings->getRetrySettings(), $timeFuncMillis);
} elseif ($settings->getTimeoutMillis() > 0) {
$apiCall = self::setTimeout($apiCall, $settings->getTimeoutMillis());
}
if (array_key_exists('pageStreamingDescriptor', $options)) {
$apiCall = self::setPageStreaming($apiCall, $options['pageStreamingDescriptor']);
}
if (array_key_exists('headerDescriptor', $options)) {
$apiCall = self::setCustomHeader($apiCall, $options['headerDescriptor']);
}
return $apiCall;
}
}
src/ApiException.php 0000644 00000003644 15174273455 0010460 0 ustar 00 code}]: {$this->message}\n";
}
}
src/BackoffSettings.php 0000644 00000015717 15174273455 0011150 0 ustar 00 $value) {
$wordsKey = str_replace('_', ' ', $key);
$camelCaseKey = str_replace(' ', '', ucwords($wordsKey));
$camelCaseSettings[lcfirst($camelCaseKey)] = $value;
}
return new BackoffSettings($camelCaseSettings);
}
/**
* Constructs an instance.
*
* @param array $settings {
* Required. Settings for configuring the backoff settings
*
* @type integer $initialRetryDelayMillis The initial delay of retry in milliseconds.
* @type integer $retryDelayMultiplier The exponential multiplier of retry delay.
* @type integer $maxRetryDelayMillis The max delay of retry in milliseconds.
* @type integer $initialRpcTimeoutMillis The initial timeout of rpc call in milliseconds.
* @type integer $rpcTimeoutMultiplier The exponential multiplier of rpc timeout.
* @type integer $maxRpcTimeoutMillis The max timout of rpc call in milliseconds.
* @type integer $totalTimeoutMillis The max accumulative timeout in total.
* }
*/
public function __construct($settings)
{
self::validate($settings);
$this->initialRetryDelayMillis = $settings['initialRetryDelayMillis'];
$this->retryDelayMultiplier = $settings['retryDelayMultiplier'];
$this->maxRetryDelayMillis = $settings['maxRetryDelayMillis'];
$this->initialRpcTimeoutMillis = $settings['initialRpcTimeoutMillis'];
$this->rpcTimeoutMultiplier = $settings['rpcTimeoutMultiplier'];
$this->maxRpcTimeoutMillis = $settings['maxRpcTimeoutMillis'];
$this->totalTimeoutMillis = $settings['totalTimeoutMillis'];
}
public function getInitialRetryDelayMillis()
{
return $this->initialRetryDelayMillis;
}
public function getRetryDelayMultiplier()
{
return $this->retryDelayMultiplier;
}
public function getMaxRetryDelayMillis()
{
return $this->maxRetryDelayMillis;
}
public function getInitialRpcTimeoutMillis()
{
return $this->initialRpcTimeoutMillis;
}
public function getRpcTimeoutMultiplier()
{
return $this->rpcTimeoutMultiplier;
}
public function getMaxRpcTimeoutMillis()
{
return $this->maxRpcTimeoutMillis;
}
public function getTotalTimeoutMillis()
{
return $this->totalTimeoutMillis;
}
private static function validate($settings)
{
$requiredFields = ['initialRetryDelayMillis',
'retryDelayMultiplier', 'maxRetryDelayMillis', 'initialRpcTimeoutMillis',
'rpcTimeoutMultiplier', 'maxRpcTimeoutMillis', 'totalTimeoutMillis'];
foreach ($requiredFields as $field) {
if (empty($settings[$field])) {
throw new InvalidArgumentException("$field is required for BackoffSettings");
}
}
}
}
src/CallSettings.php 0000644 00000017277 15174273455 0010473 0 ustar 00 $methodConfig) {
$phpMethodKey = lcfirst($methodName);
$retrySettings = null;
if (self::inheritRetrySettings($retryingOverrides, $phpMethodKey)) {
$retrySettings =
self::constructRetry(
$methodConfig,
$statusCodes,
$serviceConfig['retry_codes'],
$serviceConfig['retry_params']
);
} else {
$retrySettings = $retryingOverrides[$phpMethodKey];
}
$callSettings[$phpMethodKey] = new CallSettings(
['timeoutMillis' => $timeoutMillis,
'retrySettings' => $retrySettings]
);
}
return $callSettings;
}
private static function inheritRetrySettings($retryingOverrides, $phpMethodKey)
{
if (empty($retryingOverrides)) {
return true;
}
if (!array_key_exists($phpMethodKey, $retryingOverrides)) {
return true;
}
$retrySettings = $retryingOverrides[$phpMethodKey];
if (is_null($retrySettings)) {
// Retry has been turned off explicitly.
return false;
}
return $retrySettings->shouldInherit();
}
private static function constructRetry(
$methodConfig,
$statusCodes,
$retryCodes,
$retryParams
) {
$codes = [];
if (!empty($retryCodes)) {
foreach ($retryCodes as $retryCodesName => $retryCodeList) {
if ($retryCodesName === $methodConfig['retry_codes_name'] &&
!empty($retryCodeList)) {
foreach ($retryCodeList as $retryCodeName) {
if (!array_key_exists($retryCodeName, $statusCodes)) {
throw new InvalidArgumentException("Invalid status code: $retryCodeName");
}
array_push($codes, $statusCodes[$retryCodeName]);
}
break;
}
}
}
$backoffSettings = null;
if (!empty($methodConfig['retry_params_name'])) {
foreach ($retryParams as $retryParamsName => $retryParamValues) {
if ($retryParamsName === $methodConfig['retry_params_name']) {
$backoffSettings = BackoffSettings::fromSnakeCase($retryParamValues);
}
}
}
if (!empty($codes) && !empty($backoffSettings)) {
return new RetrySettings($codes, $backoffSettings);
} else {
return null;
}
}
/**
* Construct an instance.
*
* @param array $options {
* Optional.
* @type Google\GAX\RetrySettings $retrySettings
* Retry settings to use for this method. If present, then
* $timeout is ignored.
* @type integer $timeoutMillis
* Timeout to use for the call. Only used if $retrySettings
* is not set.
* }
*/
public function __construct($settings = [])
{
$this->timeoutMillis = self::INHERIT_TIMEOUT;
$this->retrySettings = RetrySettings::inherit();
if (array_key_exists('timeoutMillis', $settings)) {
$this->timeoutMillis = $settings['timeoutMillis'];
}
if (array_key_exists('retrySettings', $settings)) {
$this->retrySettings = $settings['retrySettings'];
}
}
public function getTimeoutMillis()
{
return $this->timeoutMillis;
}
public function getRetrySettings()
{
return $this->retrySettings;
}
/**
* Returns a new CallSettings merged from this and another CallSettings object.
*
* @param CallSettings $otherSettings
* A CallSettings whose values override those in this object. If
* null, then a copy of this object is returned.
*/
public function merge(CallSettings $otherSettings = null)
{
if (is_null($otherSettings)) {
return new CallSettings([
'timeoutMillis' => $this->timeoutMillis,
'retrySettings' => $this->retrySettings]);
} else {
$timeoutMillis = $this->timeoutMillis;
if ($otherSettings->getTimeoutMillis() != self::INHERIT_TIMEOUT) {
$timeoutMillis = $otherSettings->getTimeoutMillis();
}
$retrySettings = $this->retrySettings;
if (is_null($otherSettings->getRetrySettings())
|| !$otherSettings->getRetrySettings()->shouldInherit()) {
$retrySettings = $otherSettings->getRetrySettings();
}
return new CallSettings([
'timeoutMillis' => $timeoutMillis,
'retrySettings' => $retrySettings]);
}
}
}
src/FixedSizeCollection.php 0000644 00000013345 15174273455 0011775 0 ustar 00 0. collectionSize: $collectionSize"
);
}
if ($collectionSize < $initialPage->getPageElementCount()) {
$ipc = $initialPage->getPageElementCount();
throw new InvalidArgumentException(
"collectionSize must be greater than or equal to the number of " +
"elements in initialPage. collectionSize: $collectionSize, " +
"initialPage size: $ipc"
);
}
$this->collectionSize = $collectionSize;
$this->pageList = FixedSizeCollection::createPageArray($initialPage, $collectionSize);
}
/**
* Returns the number of elements in the collection. This will be
* equal to the collectionSize parameter used at construction
* unless there are no elements remaining to be retrieved.
*/
public function getCollectionSize()
{
$size = 0;
foreach ($this->pageList as $page) {
$size += $page->getPageElementCount();
}
return $size;
}
/**
* Returns true if there are more elements that can be retrieved
* from the API.
*/
public function hasNextCollection()
{
return $this->getLastPage()->hasNextPage();
}
/**
* Returns a page token that can be passed into the API list
* method to retrieve additional elements.
*/
public function getNextPageToken()
{
return $this->getLastPage()->getNextPageToken();
}
/**
* Retrieves the next FixedSizeCollection using one or more API calls.
*/
public function getNextCollection()
{
$lastPage = $this->getLastPage();
$nextPage = $lastPage->getNextPage($this->collectionSize);
return new FixedSizeCollection($nextPage, $this->collectionSize);
}
/**
* Returns an iterator over the elements of the collection.
*/
public function getIterator()
{
foreach ($this->pageList as $page) {
foreach ($page as $element) {
yield $element;
}
}
}
/**
* Returns an iterator over FixedSizeCollections, starting with this
* and making API calls as required until all of the elements have
* been retrieved.
*/
public function iterateCollections()
{
$currentCollection = $this;
yield $this;
while ($currentCollection->hasNextCollection()) {
$currentCollection = $currentCollection->getNextCollection();
yield $currentCollection;
}
}
private function getLastPage()
{
$pageList = $this->pageList;
// Get last element in array...
$lastPage = array_pop((array_slice($pageList, -1)));
return $lastPage;
}
private static function createPageArray($initialPage, $collectionSize)
{
$pageList = [$initialPage];
$currentPage = $initialPage;
$itemCount = $currentPage->getPageElementCount();
while ($itemCount < $collectionSize && $currentPage->hasNextPage()) {
$remainingCount = $collectionSize - $itemCount;
$currentPage = $currentPage->getNextPage($remainingCount);
$rxElementCount = $currentPage->getPageElementCount();
if ($rxElementCount > $remainingCount) {
throw new LengthException("API returned a number of elements " .
"exceeding the specified page size limit. page size: " .
"$remainingCount, elements received: $rxElementCount");
}
array_push($pageList, $currentPage);
$itemCount += $rxElementCount;
}
return $pageList;
}
}
src/GrpcConstants.php 0000644 00000006410 15174273455 0010652 0 ustar 00 Grpc\STATUS_ABORTED,
'ALREADY_EXISTS' => Grpc\STATUS_ALREADY_EXISTS,
'CANCELLED' => Grpc\STATUS_CANCELLED,
'DATA_LOSS' => Grpc\STATUS_DATA_LOSS,
'DEADLINE_EXCEEDED' => Grpc\STATUS_DEADLINE_EXCEEDED,
'FAILED_PRECONDITION' => Grpc\STATUS_FAILED_PRECONDITION,
'INTERNAL' => Grpc\STATUS_INTERNAL,
'INVALID_ARGUMENT' => Grpc\STATUS_INVALID_ARGUMENT,
'NOT_FOUND' => Grpc\STATUS_NOT_FOUND,
'OK' => Grpc\STATUS_OK,
'OUT_OF_RANGE' => Grpc\STATUS_OUT_OF_RANGE,
'PERMISSION_DENIED' => Grpc\STATUS_PERMISSION_DENIED,
'RESOURCE_EXHAUSTED' => Grpc\STATUS_RESOURCE_EXHAUSTED,
'UNAUTHENTICATED' => Grpc\STATUS_UNAUTHENTICATED,
'UNAVAILABLE' => Grpc\STATUS_UNAVAILABLE,
'UNIMPLEMENTED' => Grpc\STATUS_UNIMPLEMENTED,
'UNKNOWN' => Grpc\STATUS_UNKNOWN
];
}
/**
* Provides an array that maps from status code name to an object
* representing that status code.
*/
public static function getStatusCodeNames()
{
if (!self::$statusCodeNames) {
self::initStatusCodeNames();
}
return self::$statusCodeNames;
}
}
src/GrpcCredentialsHelper.php 0000644 00000013542 15174273455 0012277 0 ustar 00 null,
'enableCaching' => true,
];
$opts = array_merge($defaultOptions, $optionalArgs);
$cachingOptions = array_diff_key($opts, $defaultOptions);
$this->scopes = $scopes;
if (isset($opts['credentialsLoader'])) {
$credentialsLoader = $opts['credentialsLoader'];
} else {
$credentialsLoader = $this->getADCCredentials($scopes);
}
if ($opts['enableCaching']) {
$credentialsLoader = new FetchAuthTokenCache(
$credentialsLoader,
$cachingOptions,
new MemoryCacheItemPool()
);
}
$this->credentialsLoader = $credentialsLoader;
}
/**
* Creates the callback function to be passed to gRPC for providing the credentials
* for a call.
*/
public function createCallCredentialsCallback()
{
$credentialsLoader = $this->credentialsLoader;
$callback = function () use ($credentialsLoader) {
$token = $credentialsLoader->fetchAuthToken();
return ['Authorization' => array('Bearer ' . $token['access_token'])];
};
return $callback;
}
// TODO(garrettjones):
// add:
// 1. (when supported in gRPC) channel
/**
* Creates a gRPC client stub.
*
* @param function $generatedCreateStub
* Function callback which must accept two arguments ($hostname, $opts)
* and return an instance of the stub of the specific API to call.
* Generally, this should just call the stub's constructor and return
* the instance.
* @param string $serviceAddress The domain name of the API remote host.
* @param mixed $port The port on which to connect to the remote host.
* @param array $options {
* Optional. Options for configuring the gRPC stub.
*
* @type Grpc\ChannelCredentials $sslCreds
* A `ChannelCredentials` for use with an SSL-enabled channel.
* Default: a credentials object returned from
* Grpc\ChannelCredentials::createSsl()
* }
*/
public function createStub($generatedCreateStub, $serviceAddress, $port, $options = [])
{
$stubOpts = [];
if (empty($options['sslCreds'])) {
$stubOpts['credentials'] = $this->createSslChannelCredentials();
} else {
$stubOpts['credentials'] = $options['sslCreds'];
}
$fullAddress = "$serviceAddress:$port";
$stubOpts['grpc.ssl_target_name_override'] = $fullAddress;
return $generatedCreateStub($fullAddress, $stubOpts);
}
/**
* Gets credentials from ADC. This exists to allow overriding in unit tests.
*/
protected function getADCCredentials($scopes)
{
return ApplicationDefaultCredentials::getCredentials($scopes);
}
/**
* Construct ssl channel credentials. This exists to allow overriding in unit tests.
*/
protected function createSslChannelCredentials()
{
return ChannelCredentials::createSsl();
}
}
src/Jison/Parser.jison 0000644 00000010662 15174273455 0010737 0 ustar 00 /*
* Copyright 2016, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* description: Parses a path template string and returns an array of
* Segment objects.
*/
/* options */
//option namespace:Google\GAX\Jison
/* lexical grammar */
%lex
%%
\s+ /* skip whitespace */
"/" return 'FORWARD_SLASH'
"{" return 'LEFT_BRACE'
"}" return 'RIGHT_BRACE'
"=" return 'EQUALS'
"**" return 'PATH_WILDCARD'
"*" return 'WILDCARD'
[^*=}{}\/]+ return 'LITERAL'
<> /* skip EOF */
/lex
%token 'FORWARD_SLASH'
%token 'LEFT_BRACE'
%token 'RIGHT_BRACE'
%token 'EQUALS'
%token 'LITERAL'
%token 'PATH_WILDCARD'
%token 'WILDCARD'
%% /* language grammar */
/* This file is used by a php port of Jison (https://github.com/zaach/jison). */
template
: FORWARD_SLASH bound_segments
{//php return $2->text;
}
| bound_segments
{//php return $1->text;
}
;
bound_segments
: bound_segment FORWARD_SLASH bound_segments
{/*php
$t1 = $1->text;
$t3 = $3->text;
$$ = array_merge($t1, $t3);
*/}
| bound_segment
{//php $$ = $1->text;
}
;
unbound_segments
: unbound_terminal FORWARD_SLASH unbound_segments
{/*php
$t1 = $1->text;
$t3 = $3->text;
$$ = array_merge($t1, $t3);
*/}
| unbound_terminal
{//php $$ = $1->text;
}
;
bound_segment
: bound_terminal
{//php $$ = $1->text;
}
| variable
{//php $$ = $1->text;
}
;
unbound_terminal
: WILDCARD
{/*php
$t1 = $1->text;
Segment::incrementSegmentCount();
$$ = [new Segment(Segment::TERMINAL, $t1)];
*/}
| PATH_WILDCARD
{/*php
$t1 = $1->text;
Segment::incrementSegmentCount();
$$ = [new Segment(Segment::TERMINAL, $t1)];
*/}
| LITERAL
{/*php
$t1 = $1->text;
Segment::incrementSegmentCount();
$$ = [new Segment(Segment::TERMINAL, $t1)];
*/}
;
bound_terminal
: unbound_terminal
{/*php
$t1 = $1->text;
if (in_array($t1[0]['literal'], ['*', '**'])) {
$$ = [
new Segment(Segment::BINDING,
sprintf('$%d', Segment::getBindingCount())),
$t1[0],
new Segment(Segment::END_BINDING, '')
];
Segment::incrementBindingCount();
} else {
$$ = $t1;
}
*/}
;
variable
: LEFT_BRACE LITERAL EQUALS unbound_segments RIGHT_BRACE
{/*php
$t2 = $2->text;
$t4 = $4->text;
$tmp = [new Segment(Segment::BINDING, $t2)];
$tmp = array_merge($tmp, $t4);
array_push($tmp, new Segment(Segment::END_BINDING, ''));
$$ = $tmp;
*/}
| LEFT_BRACE LITERAL RIGHT_BRACE
{/*php
$t2 = $2->text;
$$ = [
new Segment(Segment::BINDING, $t2),
new Segment(Segment::TERMINAL, '*'),
new Segment(Segment::END_BINDING, '')
];
Segment::incrementSegmentCount();
*/}
;
src/Jison/Parser.php 0000644 00000072551 15174273455 0010411 0 ustar 00 symbols[0] = $symbol0;
$this->symbols["accept"] = $symbol0;
$this->symbols[1] = $symbol1;
$this->symbols["end"] = $symbol1;
$this->symbols[2] = $symbol2;
$this->symbols["error"] = $symbol2;
$this->symbols[3] = $symbol3;
$this->symbols["template"] = $symbol3;
$this->symbols[4] = $symbol4;
$this->symbols["FORWARD_SLASH"] = $symbol4;
$this->symbols[5] = $symbol5;
$this->symbols["bound_segments"] = $symbol5;
$this->symbols[6] = $symbol6;
$this->symbols["bound_segment"] = $symbol6;
$this->symbols[7] = $symbol7;
$this->symbols["unbound_segments"] = $symbol7;
$this->symbols[8] = $symbol8;
$this->symbols["unbound_terminal"] = $symbol8;
$this->symbols[9] = $symbol9;
$this->symbols["bound_terminal"] = $symbol9;
$this->symbols[10] = $symbol10;
$this->symbols["variable"] = $symbol10;
$this->symbols[11] = $symbol11;
$this->symbols["WILDCARD"] = $symbol11;
$this->symbols[12] = $symbol12;
$this->symbols["PATH_WILDCARD"] = $symbol12;
$this->symbols[13] = $symbol13;
$this->symbols["LITERAL"] = $symbol13;
$this->symbols[14] = $symbol14;
$this->symbols["LEFT_BRACE"] = $symbol14;
$this->symbols[15] = $symbol15;
$this->symbols["EQUALS"] = $symbol15;
$this->symbols[16] = $symbol16;
$this->symbols["RIGHT_BRACE"] = $symbol16;
$this->terminals = array(
2=>&$symbol2,
4=>&$symbol4,
11=>&$symbol11,
12=>&$symbol12,
13=>&$symbol13,
14=>&$symbol14,
15=>&$symbol15,
16=>&$symbol16
);
$table0 = new ParserState(0);
$table1 = new ParserState(1);
$table2 = new ParserState(2);
$table3 = new ParserState(3);
$table4 = new ParserState(4);
$table5 = new ParserState(5);
$table6 = new ParserState(6);
$table7 = new ParserState(7);
$table8 = new ParserState(8);
$table9 = new ParserState(9);
$table10 = new ParserState(10);
$table11 = new ParserState(11);
$table12 = new ParserState(12);
$table13 = new ParserState(13);
$table14 = new ParserState(14);
$table15 = new ParserState(15);
$table16 = new ParserState(16);
$table17 = new ParserState(17);
$table18 = new ParserState(18);
$table19 = new ParserState(19);
$table20 = new ParserState(20);
$table21 = new ParserState(21);
$table22 = new ParserState(22);
$tableDefinition0 = array(
3=>new ParserAction($this->none, $table1),
4=>new ParserAction($this->shift, $table2),
5=>new ParserAction($this->none, $table3),
6=>new ParserAction($this->none, $table4),
8=>new ParserAction($this->none, $table7),
9=>new ParserAction($this->none, $table5),
10=>new ParserAction($this->none, $table6),
11=>new ParserAction($this->shift, $table9),
12=>new ParserAction($this->shift, $table10),
13=>new ParserAction($this->shift, $table11),
14=>new ParserAction($this->shift, $table8)
);
$tableDefinition1 = array(
1=>new ParserAction($this->accept)
);
$tableDefinition2 = array(
5=>new ParserAction($this->none, $table12),
6=>new ParserAction($this->none, $table4),
8=>new ParserAction($this->none, $table7),
9=>new ParserAction($this->none, $table5),
10=>new ParserAction($this->none, $table6),
11=>new ParserAction($this->shift, $table9),
12=>new ParserAction($this->shift, $table10),
13=>new ParserAction($this->shift, $table11),
14=>new ParserAction($this->shift, $table8)
);
$tableDefinition3 = array(
1=>new ParserAction($this->reduce, $table2)
);
$tableDefinition4 = array(
1=>new ParserAction($this->reduce, $table4),
4=>new ParserAction($this->shift, $table13)
);
$tableDefinition5 = array(
1=>new ParserAction($this->reduce, $table7),
4=>new ParserAction($this->reduce, $table7)
);
$tableDefinition6 = array(
1=>new ParserAction($this->reduce, $table8),
4=>new ParserAction($this->reduce, $table8)
);
$tableDefinition7 = array(
1=>new ParserAction($this->reduce, $table12),
4=>new ParserAction($this->reduce, $table12)
);
$tableDefinition8 = array(
13=>new ParserAction($this->shift, $table14)
);
$tableDefinition9 = array(
1=>new ParserAction($this->reduce, $table9),
4=>new ParserAction($this->reduce, $table9),
16=>new ParserAction($this->reduce, $table9)
);
$tableDefinition10 = array(
1=>new ParserAction($this->reduce, $table10),
4=>new ParserAction($this->reduce, $table10),
16=>new ParserAction($this->reduce, $table10)
);
$tableDefinition11 = array(
1=>new ParserAction($this->reduce, $table11),
4=>new ParserAction($this->reduce, $table11),
16=>new ParserAction($this->reduce, $table11)
);
$tableDefinition12 = array(
1=>new ParserAction($this->reduce, $table1)
);
$tableDefinition13 = array(
5=>new ParserAction($this->none, $table15),
6=>new ParserAction($this->none, $table4),
8=>new ParserAction($this->none, $table7),
9=>new ParserAction($this->none, $table5),
10=>new ParserAction($this->none, $table6),
11=>new ParserAction($this->shift, $table9),
12=>new ParserAction($this->shift, $table10),
13=>new ParserAction($this->shift, $table11),
14=>new ParserAction($this->shift, $table8)
);
$tableDefinition14 = array(
15=>new ParserAction($this->shift, $table16),
16=>new ParserAction($this->shift, $table17)
);
$tableDefinition15 = array(
1=>new ParserAction($this->reduce, $table3)
);
$tableDefinition16 = array(
7=>new ParserAction($this->none, $table18),
8=>new ParserAction($this->none, $table19),
11=>new ParserAction($this->shift, $table9),
12=>new ParserAction($this->shift, $table10),
13=>new ParserAction($this->shift, $table11)
);
$tableDefinition17 = array(
1=>new ParserAction($this->reduce, $table14),
4=>new ParserAction($this->reduce, $table14)
);
$tableDefinition18 = array(
16=>new ParserAction($this->shift, $table20)
);
$tableDefinition19 = array(
4=>new ParserAction($this->shift, $table21),
16=>new ParserAction($this->reduce, $table6)
);
$tableDefinition20 = array(
1=>new ParserAction($this->reduce, $table13),
4=>new ParserAction($this->reduce, $table13)
);
$tableDefinition21 = array(
7=>new ParserAction($this->none, $table22),
8=>new ParserAction($this->none, $table19),
11=>new ParserAction($this->shift, $table9),
12=>new ParserAction($this->shift, $table10),
13=>new ParserAction($this->shift, $table11)
);
$tableDefinition22 = array(
16=>new ParserAction($this->reduce, $table5)
);
$table0->setActions($tableDefinition0);
$table1->setActions($tableDefinition1);
$table2->setActions($tableDefinition2);
$table3->setActions($tableDefinition3);
$table4->setActions($tableDefinition4);
$table5->setActions($tableDefinition5);
$table6->setActions($tableDefinition6);
$table7->setActions($tableDefinition7);
$table8->setActions($tableDefinition8);
$table9->setActions($tableDefinition9);
$table10->setActions($tableDefinition10);
$table11->setActions($tableDefinition11);
$table12->setActions($tableDefinition12);
$table13->setActions($tableDefinition13);
$table14->setActions($tableDefinition14);
$table15->setActions($tableDefinition15);
$table16->setActions($tableDefinition16);
$table17->setActions($tableDefinition17);
$table18->setActions($tableDefinition18);
$table19->setActions($tableDefinition19);
$table20->setActions($tableDefinition20);
$table21->setActions($tableDefinition21);
$table22->setActions($tableDefinition22);
$this->table = array(
0=>$table0,
1=>$table1,
2=>$table2,
3=>$table3,
4=>$table4,
5=>$table5,
6=>$table6,
7=>$table7,
8=>$table8,
9=>$table9,
10=>$table10,
11=>$table11,
12=>$table12,
13=>$table13,
14=>$table14,
15=>$table15,
16=>$table16,
17=>$table17,
18=>$table18,
19=>$table19,
20=>$table20,
21=>$table21,
22=>$table22
);
$this->defaultActions = array(
3=>new ParserAction($this->reduce, $table2),
12=>new ParserAction($this->reduce, $table1),
15=>new ParserAction($this->reduce, $table3),
22=>new ParserAction($this->reduce, $table5)
);
$this->productions = array(
0=>new ParserProduction($symbol0),
1=>new ParserProduction($symbol3,2),
2=>new ParserProduction($symbol3,1),
3=>new ParserProduction($symbol5,3),
4=>new ParserProduction($symbol5,1),
5=>new ParserProduction($symbol7,3),
6=>new ParserProduction($symbol7,1),
7=>new ParserProduction($symbol6,1),
8=>new ParserProduction($symbol6,1),
9=>new ParserProduction($symbol8,1),
10=>new ParserProduction($symbol8,1),
11=>new ParserProduction($symbol8,1),
12=>new ParserProduction($symbol9,1),
13=>new ParserProduction($symbol10,5),
14=>new ParserProduction($symbol10,3)
);
//Setup Lexer
$this->rules = array(
0=>"/^(?:\s+)/",
1=>"/^(?:\/)/",
2=>"/^(?:\{)/",
3=>"/^(?:\})/",
4=>"/^(?:=)/",
5=>"/^(?:\*\*)/",
6=>"/^(?:\*)/",
7=>"/^(?:[^*=}{}\/]+)/",
8=>"/^(?:$)/"
);
$this->conditions = array(
"INITIAL"=>new LexerConditions(array( 0,1,2,3,4,5,6,7,8), true)
);
}
function parserPerformAction(&$thisS, &$yy, $yystate, &$s, $o)
{
/* this == yyval */
switch ($yystate) {
case 1: case 2:
return $s[$o]->text;
break;
case 3: case 5:
$t1 = $s[$o-2]->text;
$t3 = $s[$o]->text;
$thisS = array_merge($t1, $t3);
break;
case 4: case 6: case 7: case 8:
$thisS = $s[$o]->text;
break;
case 9: case 10: case 11:
$t1 = $s[$o]->text;
Segment::incrementSegmentCount();
$thisS = [new Segment(Segment::TERMINAL, $t1)];
break;
case 12:
$t1 = $s[$o]->text;
if (in_array($t1[0]['literal'], ['*', '**'])) {
$thisS = [
new Segment(Segment::BINDING,
sprintf('$%d', Segment::getBindingCount())),
$t1[0],
new Segment(Segment::END_BINDING, '')
];
Segment::incrementBindingCount();
} else {
$thisS = $t1;
}
break;
case 13:
$t2 = $s[$o-3]->text;
$t4 = $s[$o-1]->text;
$tmp = [new Segment(Segment::BINDING, $t2)];
$tmp = array_merge($tmp, $t4);
array_push($tmp, new Segment(Segment::END_BINDING, ''));
$thisS = $tmp;
break;
case 14:
$t2 = $s[$o-1]->text;
$thisS = [
new Segment(Segment::BINDING, $t2),
new Segment(Segment::TERMINAL, '*'),
new Segment(Segment::END_BINDING, '')
];
Segment::incrementSegmentCount();
break;
}
}
function parserLex()
{
$token = $this->lexerLex(); // $end = 1
if (isset($token)) {
return $token;
}
return $this->symbols["end"];
}
function parseError($str = "", ParserError $hash = null)
{
throw new Exception($str);
}
function lexerError($str = "", LexerError $hash = null)
{
throw new Exception($str);
}
function parse($input)
{
if (empty($this->table)) {
throw new Exception("Empty Table");
}
$this->eof = new ParserSymbol("Eof", 1);
$firstAction = new ParserAction(0, $this->table[0]);
$firstCachedAction = new ParserCachedAction($firstAction);
$stack = array($firstCachedAction);
$stackCount = 1;
$vstack = array(null);
$vstackCount = 1;
$yy = null;
$_yy = null;
$recovering = 0;
$symbol = null;
$action = null;
$errStr = "";
$preErrorSymbol = null;
$state = null;
$this->setInput($input);
while (true) {
// retrieve state number from top of stack
$state = $stack[$stackCount - 1]->action->state;
// use default actions if available
if ($state != null && isset($this->defaultActions[$state->index])) {
$action = $this->defaultActions[$state->index];
} else {
if (empty($symbol) == true) {
$symbol = $this->parserLex();
}
// read action for current state and first input
if (isset($state) && isset($state->actions[$symbol->index])) {
//$action = $this->table[$state][$symbol];
$action = $state->actions[$symbol->index];
} else {
$action = null;
}
}
if ($action == null) {
if ($recovering == 0) {
// Report error
$expected = array();
foreach($this->table[$state->index]->actions as $p => $item) {
if (!empty($this->terminals[$p]) && $p > 2) {
$expected[] = $this->terminals[$p]->name;
}
}
$errStr = "Parse error on line " . ($this->yy->lineNo + 1) . ":\n" . $this->showPosition() . "\nExpecting " . implode(", ", $expected) . ", got '" . (isset($this->terminals[$symbol->index]) ? $this->terminals[$symbol->index]->name : 'NOTHING') . "'";
$this->parseError($errStr, new ParserError($this->match, $state, $symbol, $this->yy->lineNo, $this->yy->loc, $expected));
}
}
if ($state === null || $action === null) {
break;
}
switch ($action->action) {
case 1:
// shift
//$this->shiftCount++;
$stack[] = new ParserCachedAction($action, $symbol);
$stackCount++;
$vstack[] = clone($this->yy);
$vstackCount++;
$symbol = "";
if ($preErrorSymbol == null) { // normal execution/no error
$yy = clone($this->yy);
if ($recovering > 0) $recovering--;
} else { // error just occurred, resume old look ahead f/ before error
$symbol = $preErrorSymbol;
$preErrorSymbol = null;
}
break;
case 2:
// reduce
$len = $this->productions[$action->state->index]->len;
// perform semantic action
$_yy = $vstack[$vstackCount - $len];// default to $S = $1
// default location, uses first token for firsts, last for lasts
if (isset($this->ranges)) {
//TODO: add ranges
}
$r = $this->parserPerformAction($_yy->text, $yy, $action->state->index, $vstack, $vstackCount - 1);
if (isset($r)) {
return $r;
}
// pop off stack
while ($len > 0) {
$len--;
array_pop($stack);
$stackCount--;
array_pop($vstack);
$vstackCount--;
}
if (is_null($_yy))
{
$vstack[] = new ParserValue();
}
else
{
$vstack[] = $_yy;
}
$vstackCount++;
$nextSymbol = $this->productions[$action->state->index]->symbol;
// goto new state = table[STATE][NONTERMINAL]
$nextState = $stack[$stackCount - 1]->action->state;
$nextAction = $nextState->actions[$nextSymbol->index];
$stack[] = new ParserCachedAction($nextAction, $nextSymbol);
$stackCount++;
break;
case 3:
// accept
return true;
}
}
return true;
}
/* Jison generated lexer */
public $eof;
public $yy = null;
public $match = "";
public $matched = "";
public $conditionStack = array();
public $conditionStackCount = 0;
public $rules = array();
public $conditions = array();
public $done = false;
public $less;
public $more;
public $input;
public $offset;
public $ranges;
public $flex = false;
function setInput($input)
{
$this->input = $input;
$this->more = $this->less = $this->done = false;
$this->yy = new ParserValue();
$this->conditionStack = array('INITIAL');
$this->conditionStackCount = 1;
if (isset($this->ranges)) {
$loc = $this->yy->loc = new ParserLocation();
$loc->Range(new ParserRange(0, 0));
} else {
$this->yy->loc = new ParserLocation();
}
$this->offset = 0;
}
function input()
{
$ch = $this->input[0];
$this->yy->text .= $ch;
$this->yy->leng++;
$this->offset++;
$this->match .= $ch;
$this->matched .= $ch;
$lines = preg_match("/(?:\r\n?|\n).*/", $ch);
if (count($lines) > 0) {
$this->yy->lineNo++;
$this->yy->lastLine++;
} else {
$this->yy->loc->lastColumn++;
}
if (isset($this->ranges)) {
$this->yy->loc->range->y++;
}
$this->input = array_slice($this->input, 1);
return $ch;
}
function unput($ch)
{
$len = strlen($ch);
$lines = explode("/(?:\r\n?|\n)/", $ch);
$linesCount = count($lines);
$this->input = $ch . $this->input;
$this->yy->text = substr($this->yy->text, 0, $len - 1);
//$this->yylen -= $len;
$this->offset -= $len;
$oldLines = explode("/(?:\r\n?|\n)/", $this->match);
$oldLinesCount = count($oldLines);
$this->match = substr($this->match, 0, strlen($this->match) - 1);
$this->matched = substr($this->matched, 0, strlen($this->matched) - 1);
if (($linesCount - 1) > 0) $this->yy->lineNo -= $linesCount - 1;
$r = $this->yy->loc->range;
$oldLinesLength = (isset($oldLines[$oldLinesCount - $linesCount]) ? strlen($oldLines[$oldLinesCount - $linesCount]) : 0);
$this->yy->loc = new ParserLocation(
$this->yy->loc->firstLine,
$this->yy->lineNo,
$this->yy->loc->firstColumn,
$this->yy->loc->firstLine,
(empty($lines) ?
($linesCount == $oldLinesCount ? $this->yy->loc->firstColumn : 0) + $oldLinesLength :
$this->yy->loc->firstColumn - $len)
);
if (isset($this->ranges)) {
$this->yy->loc->range = array($r[0], $r[0] + $this->yy->leng - $len);
}
}
function more()
{
$this->more = true;
}
function pastInput()
{
$past = substr($this->matched, 0, strlen($this->matched) - strlen($this->match));
return (strlen($past) > 20 ? '...' : '') . preg_replace("/\n/", "", substr($past, -20));
}
function upcomingInput()
{
$next = $this->match;
if (strlen($next) < 20) {
$next .= substr($this->input, 0, 20 - strlen($next));
}
return preg_replace("/\n/", "", substr($next, 0, 20) . (strlen($next) > 20 ? '...' : ''));
}
function showPosition()
{
$pre = $this->pastInput();
$c = '';
for($i = 0, $preLength = strlen($pre); $i < $preLength; $i++) {
$c .= '-';
}
return $pre . $this->upcomingInput() . "\n" . $c . "^";
}
function next()
{
if ($this->done == true) {
return $this->eof;
}
if (empty($this->input)) {
$this->done = true;
}
if ($this->more == false) {
$this->yy->text = '';
$this->match = '';
}
$rules = $this->currentRules();
for ($i = 0, $j = count($rules); $i < $j; $i++) {
preg_match($this->rules[$rules[$i]], $this->input, $tempMatch);
if ($tempMatch && (empty($match) || count($tempMatch[0]) > count($match[0]))) {
$match = $tempMatch;
$index = $i;
if (isset($this->flex) && $this->flex == false) {
break;
}
}
}
if ( $match ) {
$matchCount = strlen($match[0]);
$lineCount = preg_match("/(?:\r\n?|\n).*/", $match[0], $lines);
$line = ($lines ? $lines[$lineCount - 1] : false);
$this->yy->lineNo += $lineCount;
$this->yy->loc = new ParserLocation(
$this->yy->loc->lastLine,
$this->yy->lineNo + 1,
$this->yy->loc->lastColumn,
($line ?
count($line) - preg_match("/\r?\n?/", $line, $na) :
$this->yy->loc->lastColumn + $matchCount
)
);
$this->yy->text .= $match[0];
$this->match .= $match[0];
$this->matches = $match;
$this->matched .= $match[0];
$this->yy->leng = strlen($this->yy->text);
if (isset($this->ranges)) {
$this->yy->loc->range = new ParserRange($this->offset, $this->offset += $this->yy->leng);
}
$this->more = false;
$this->input = substr($this->input, $matchCount, strlen($this->input));
$ruleIndex = $rules[$index];
$nextCondition = $this->conditionStack[$this->conditionStackCount - 1];
$token = $this->lexerPerformAction($ruleIndex, $nextCondition);
if ($this->done == true && empty($this->input) == false) {
$this->done = false;
}
if (empty($token) == false) {
return $this->symbols[
$token
];
} else {
return null;
}
}
if (empty($this->input)) {
return $this->eof;
} else {
$this->lexerError("Lexical error on line " . ($this->yy->lineNo + 1) . ". Unrecognized text.\n" . $this->showPosition(), new LexerError("", -1, $this->yy->lineNo));
return null;
}
}
function lexerLex()
{
$r = $this->next();
while (is_null($r) && !$this->done) {
$r = $this->next();
}
return $r;
}
function begin($condition)
{
$this->conditionStackCount++;
$this->conditionStack[] = $condition;
}
function popState()
{
$this->conditionStackCount--;
return array_pop($this->conditionStack);
}
function currentRules()
{
$peek = $this->conditionStack[$this->conditionStackCount - 1];
return $this->conditions[$peek]->rules;
}
function LexerPerformAction($avoidingNameCollisions, $YY_START = null)
{
;
switch($avoidingNameCollisions) {
case 0:/* skip whitespace */
break;
case 1:return 4;
break;
case 2:return 14;
break;
case 3:return 16;
break;
case 4:return 15;
break;
case 5:return 12;
break;
case 6:return 11;
break;
case 7:return 13;
break;
case 8:/* skip EOF */
break;
}
}
}
class ParserLocation
{
public $firstLine = 1;
public $lastLine = 0;
public $firstColumn = 1;
public $lastColumn = 0;
public $range;
public function __construct($firstLine = 1, $lastLine = 0, $firstColumn = 1, $lastColumn = 0)
{
$this->firstLine = $firstLine;
$this->lastLine = $lastLine;
$this->firstColumn = $firstColumn;
$this->lastColumn = $lastColumn;
}
public function Range($range)
{
$this->range = $range;
}
public function __clone()
{
return new ParserLocation($this->firstLine, $this->lastLine, $this->firstColumn, $this->lastColumn);
}
}
class ParserValue
{
public $leng = 0;
public $loc;
public $lineNo = 0;
public $text;
function __clone() {
$clone = new ParserValue();
$clone->leng = $this->leng;
if (isset($this->loc)) {
$clone->loc = clone $this->loc;
}
$clone->lineNo = $this->lineNo;
$clone->text = $this->text;
return $clone;
}
}
class LexerConditions
{
public $rules;
public $inclusive;
function __construct($rules, $inclusive)
{
$this->rules = $rules;
$this->inclusive = $inclusive;
}
}
class ParserProduction
{
public $len = 0;
public $symbol;
public function __construct($symbol, $len = 0)
{
$this->symbol = $symbol;
$this->len = $len;
}
}
class ParserCachedAction
{
public $action;
public $symbol;
function __construct($action, $symbol = null)
{
$this->action = $action;
$this->symbol = $symbol;
}
}
class ParserAction
{
public $action;
public $state;
public $symbol;
function __construct($action, &$state = null, &$symbol = null)
{
$this->action = $action;
$this->state = $state;
$this->symbol = $symbol;
}
}
class ParserSymbol
{
public $name;
public $index = -1;
public $symbols = array();
public $symbolsByName = array();
function __construct($name, $index)
{
$this->name = $name;
$this->index = $index;
}
public function addAction($a)
{
$this->symbols[$a->index] = $this->symbolsByName[$a->name] = $a;
}
}
class ParserError
{
public $text;
public $state;
public $symbol;
public $lineNo;
public $loc;
public $expected;
function __construct($text, $state, $symbol, $lineNo, $loc, $expected)
{
$this->text = $text;
$this->state = $state;
$this->symbol = $symbol;
$this->lineNo = $lineNo;
$this->loc = $loc;
$this->expected = $expected;
}
}
class LexerError
{
public $text;
public $token;
public $lineNo;
public function __construct($text, $token, $lineNo)
{
$this->text = $text;
$this->token = $token;
$this->lineNo = $lineNo;
}
}
class ParserState
{
public $index;
public $actions = array();
function __construct($index)
{
$this->index = $index;
}
public function setActions(&$actions)
{
$this->actions = $actions;
}
}
class ParserRange
{
public $x;
public $y;
function __construct($x, $y)
{
$this->x = $x;
$this->y = $y;
}
}
src/Jison/Segment.php 0000644 00000005261 15174273455 0010551 0 ustar 00 kind = $kind;
$this->literal = $literal;
$this['kind'] = $kind;
$this['literal'] = $literal;
}
public static function getBindingCount()
{
return self::$bindingCount;
}
public static function incrementBindingCount()
{
self::$bindingCount++;
}
public static function resetBindingCount()
{
self::$bindingCount = 0;
}
public static function getSegmentCount()
{
return self::$segmentCount;
}
public static function incrementSegmentCount()
{
self::$segmentCount++;
}
public static function resetSegmentCount()
{
self::$segmentCount = 0;
}
}
src/Page.php 0000644 00000013176 15174273455 0006745 0 ustar 00 parameters = $params;
$this->callable = $callable;
$this->pageStreamingDescriptor = $pageStreamingDescriptor;
$requestPageTokenField = $this->pageStreamingDescriptor->getRequestPageTokenField();
$this->pageToken = $params[0]->$requestPageTokenField;
// Make gRPC call eagerly
$this->response = call_user_func_array($this->callable, $this->parameters);
}
/**
* Returns true if there are more pages that can be retrieved from the
* API.
*/
public function hasNextPage()
{
return strcmp($this->getNextPageToken(), Page::FINAL_PAGE_TOKEN) != 0;
}
/**
* Returns the next page token from the response.
*/
public function getNextPageToken()
{
$responsePageTokenField = $this->pageStreamingDescriptor->getResponsePageTokenField();
return $this->getResponseObject()->$responsePageTokenField;
}
/**
* Retrieves the next Page object using the next page token.
*/
public function getNextPage($pageSize = null)
{
if (!$this->hasNextPage()) {
throw new ValidationException(
'Could not complete getNextPage operation: ' .
'there are no more pages to retrieve.'
);
}
$newRequest = clone $this->getRequestObject();
$requestPageTokenField = $this->pageStreamingDescriptor->getRequestPageTokenField();
$newRequest->$requestPageTokenField = $this->getNextPageToken();
if (isset($pageSize)) {
if (!$this->pageStreamingDescriptor->requestHasPageSizeField()) {
throw new ValidationException(
'pageSize argument was defined, but the method does not ' .
'support a page size parameter in the optional array argument'
);
}
$requestPageSizeField = $this->pageStreamingDescriptor->getRequestPageSizeField();
$newRequest->$requestPageSizeField = $pageSize;
}
$nextParameters = [$newRequest, $this->parameters[1], $this->parameters[2]];
return new Page($nextParameters, $this->callable, $this->pageStreamingDescriptor);
}
/**
* Return the number of elements in the response.
*/
public function getPageElementCount()
{
$resourceField = $this->pageStreamingDescriptor->getResourceField();
return count($this->getResponseObject()->$resourceField);
}
/**
* Return an iterator over the elements in the response.
*/
public function getIterator()
{
$resourceField = $this->pageStreamingDescriptor->getResourceField();
foreach ($this->getResponseObject()->$resourceField as $element) {
yield $element;
}
}
/**
* Return an iterator over Page objects, beginning with this object.
* Additional Page objects are retrieved lazily via API calls until
* all elements have been retrieved.
*/
public function iteratePages()
{
$currentPage = $this;
yield $this;
while ($currentPage->hasNextPage()) {
$currentPage = $currentPage->getNextPage();
yield $currentPage;
}
}
/**
* Gets the request object used to generate the Page.
*/
public function getRequestObject()
{
return $this->parameters[0];
}
/**
* Gets the API response object.
*/
public function getResponseObject()
{
return $this->response;
}
}
src/PageStreamingDescriptor.php 0000644 00000007125 15174273455 0012653 0 ustar 00 requestPageTokenField = $descriptor['requestPageTokenField'];
if (isset($descriptor['requestPageSizeField'])) {
$this->requestPageSizeField = $descriptor['requestPageSizeField'];
} else {
$this->requestPageSizeField = null;
}
$this->responsePageTokenField = $descriptor['responsePageTokenField'];
$this->resourceField = $descriptor['resourceField'];
}
public function getRequestPageTokenField()
{
return $this->requestPageTokenField;
}
public function getRequestPageSizeField()
{
return $this->requestPageSizeField;
}
public function requestHasPageSizeField()
{
return isset($this->requestPageSizeField);
}
public function getResponsePageTokenField()
{
return $this->responsePageTokenField;
}
public function getResourceField()
{
return $this->resourceField;
}
private static function validate($descriptor)
{
$requiredFields = ['requestPageTokenField', 'responsePageTokenField', 'resourceField'];
foreach ($requiredFields as $field) {
if (empty($descriptor[$field])) {
throw new InvalidArgumentException(
"$field is required for PageStreamingDescriptor"
);
}
}
}
}
src/PagedListResponse.php 0000644 00000016344 15174273455 0011464 0 ustar 00 parameters = $params;
$this->callable = $callable;
$this->pageStreamingDescriptor = $pageStreamingDescriptor;
// Eagerly construct the first page
$this->getPage();
}
/**
* Returns an iterator over the full list of elements. Elements
* of the list are retrieved lazily using the underlying API.
*/
public function iterateAllElements()
{
foreach ($this->iteratePages() as $page) {
foreach ($page as $element) {
yield $element;
}
}
}
/**
* Return the current page of results. If the page has not
* previously been accessed, it will be retrieved with a call to
* the underlying API.
*/
public function getPage()
{
if (!isset($this->firstPage)) {
$this->firstPage = new Page(
$this->parameters,
$this->callable,
$this->pageStreamingDescriptor
);
}
return $this->firstPage;
}
/**
* Returns an iterator over pages of results. The pages are
* retrieved lazily from the underlying API.
*/
public function iteratePages()
{
return $this->getPage()->iteratePages();
}
/**
* Returns a collection of elements with a fixed size set by
* the collectionSize parameter. The collection will only contain
* fewer than collectionSize elements if there are no more
* pages to be retrieved from the server.
*
* NOTE: it is an error to call this method if an optional parameter
* to set the page size is not supported or has not been set in the
* original API call. It is also an error if the collectionSize parameter
* is less than the page size that has been set.
*/
public function expandToFixedSizeCollection($collectionSize)
{
if (!$this->pageStreamingDescriptor->requestHasPageSizeField()) {
throw new ValidationException(
"FixedSizeCollection is not supported for this method, because " .
"the method does not support an optional argument to set the " .
"page size."
);
}
// The first page has been eagerly constructed, so we do not need to
// update the page size parameter before calling getPage
$page = $this->getPage();
$request = $page->getRequestObject();
$pageSizeField = $this->pageStreamingDescriptor->getRequestPageSizeField();
if (!isset($request->$pageSizeField)) {
throw new ValidationException(
"Error while expanding Page to FixedSizeCollection: No page size " .
"parameter found. The page size parameter must be set in the API " .
"optional arguments array, and must be less than the collectionSize " .
"parameter, in order to create a FixedSizeCollection object."
);
}
$pageSize = $request->$pageSizeField;
if ($pageSize > $collectionSize) {
throw new ValidationException(
"Error while expanding Page to FixedSizeCollection: collectionSize " .
"parameter is less than the page size optional argument specified in " .
"the API call. collectionSize: $collectionSize, page size: $pageSize"
);
}
return new FixedSizeCollection($this->getPage(), $collectionSize);
}
/**
* Returns an iterator over fixed size collections of results.
* The collections are retrieved lazily from the underlying API.
*
* Each collection will have collectionSize elements, with the
* exception of the final collection which may contain fewer
* elements.
*
* NOTE: it is an error to call this method if an optional parameter
* to set the page size is not supported or has not been set in the
* original API call. It is also an error if the collectionSize parameter
* is less than the page size that has been set.
*/
public function iterateFixedSizeCollections($collectionSize)
{
return $this->expandToFixedSizeCollection($collectionSize)->iterateCollections();
}
}
src/Parser.php 0000644 00000006210 15174273455 0007314 0 ustar 00 parser = new BaseParser();
}
/**
* Returns an array of path template segments parsed from data.
*
* @param string $data A path template string
*
* @throws ValidationException when $data cannot be parsed
*
* @return array An array of Segment
*/
public function parse($data)
{
try {
Segment::resetSegmentCount();
Segment::resetBindingCount();
$segments = $this->parser->parse($data);
$this->segmentCount = Segment::getSegmentCount();
// Validation step: checks that there are no nested bindings.
$pathWildcard = false;
foreach ($segments as $segment) {
if ($segment->kind == Segment::TERMINAL &&
$segment->literal == '**') {
if ($pathWildcard) {
throw new ValidationException(
'validation error: path template cannot contain '.
'more than one path wildcard'
);
}
$pathWildcard = true;
}
}
return $segments;
} catch (Exception $e) {
throw new ValidationException('Exception in parser', 0, $e);
}
}
public function getSegmentCount()
{
return $this->segmentCount;
}
}
src/PathTemplate.php 0000644 00000014630 15174273455 0010455 0 ustar 00 segments = $parser->parse($data);
$this->segmentCount = $parser->getSegmentCount();
}
public function __toString()
{
return self::format($this->segments);
}
public function count()
{
return $this->segmentCount;
}
/**
* Renders a path template using the provided bindings.
*
* @param array $bindings An array matching var names to binding strings.
*
* @throws ValidationException if a key isn't provided or if a sub-template
* can't be parsed.
*
* @return string A rendered representation of this path template.
*/
public function render($bindings)
{
$out = [];
$binding = false;
foreach ($this->segments as $segment) {
if ($segment->kind == Segment::BINDING) {
if (!array_key_exists($segment->literal, $bindings)) {
throw new ValidationException(
sprintf(
'render error: value for key "%s" not '.
'provided',
$segment->literal
)
);
}
$out = array_merge(
$out,
(new self($bindings[$segment->literal]))->segments
);
$binding = true;
} elseif ($segment->kind == Segment::END_BINDING) {
$binding = false;
} else {
if ($binding) {
continue;
}
array_push($out, $segment);
}
}
$path = self::format($out);
$this->match($path);
return $path;
}
/**
* Matches a fully qualified path template string.
*
* @param string $path A fully qualified path template string.
*
* @throws ValidationException if path can't be matched to the template.
*
* @return array Array matching var names to binding values.
*/
public function match($path)
{
$segments = $this->segments;
$pathList = explode('/', $path);
$currentVar = null;
$bindings = [];
$segmentCount = $this->segmentCount;
$pathIndex = 0;
foreach ($segments as $segment) {
if ($pathIndex >= count($pathList)) {
break;
}
if ($segment->kind == Segment::TERMINAL) {
$pathItem = $pathList[$pathIndex];
if ($segment->literal == '*') {
$bindings[$currentVar] = $pathItem;
$pathIndex += 1;
} elseif ($segment->literal == '**') {
$length = count($pathList) - $segmentCount + 1;
$segmentCount += count($pathList) - $segmentCount;
$bindings[$currentVar] = implode(
'/',
array_slice($pathList, $pathIndex, $length)
);
$pathIndex += $length;
} elseif ($segment->literal != $pathItem) {
throw new ValidationException(
sprintf(
'mismatched literal: "%s" != "%s"',
$segment->literal,
$pathItem
)
);
} else {
$pathIndex += 1;
}
} elseif ($segment->kind == Segment::BINDING) {
$currentVar = $segment->literal;
}
}
if (($pathIndex != count($pathList)) || ($pathIndex != $segmentCount)) {
throw new ValidationException(
sprintf(
'match error: could not render a path template '.
'from %s',
$path
)
);
}
return $bindings;
}
private static function format($segments)
{
$template = '';
$slash = true;
foreach ($segments as $segment) {
if ($segment->kind == Segment::TERMINAL) {
if ($slash) {
$template .= '/';
}
$template .= $segment->literal;
}
$slash = true;
if ($segment->kind == Segment::BINDING) {
$template .= sprintf('/{%s=', $segment->literal);
$slash = false;
}
if ($segment->kind == Segment::END_BINDING) {
$template .= sprintf('%s}', $segment->literal);
}
}
// Remove leading '/'
return substr($template, 1);
}
}
src/RetrySettings.php 0000644 00000005600 15174273455 0010710 0 ustar 00 inherit = true;
return $retrySettings;
}
/**
* Construct an instance.
*/
public function __construct($retryableCodes, $backoffSettings)
{
$this->retryableCodes = $retryableCodes;
$this->backoffSettings = $backoffSettings;
$this->inherit = false;
}
public function getRetryableCodes()
{
return $this->retryableCodes;
}
public function getBackoffSettings()
{
return $this->backoffSettings;
}
public function shouldInherit()
{
return $this->inherit;
}
}
src/ValidationException.php 0000644 00000003170 15174273455 0012033 0 ustar 00 number = 72295728;
$f->name = "google\api\http";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\HttpRule';
return $f;
});
} src/generated/auth.php 0000644 00000041302 15174273455 0010760 0 ustar 00 number = 3;
$f->name = "rules";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\AuthenticationRule';
$descriptor->addField($f);
// REPEATED MESSAGE providers = 4
$f = new \DrSlump\Protobuf\Field();
$f->number = 4;
$f->name = "providers";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\AuthProvider';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRules(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\Authentication
*/
public function clearRules(){
return $this->_clear(3);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\AuthenticationRule
*/
public function getRules($idx = NULL){
return $this->_get(3, $idx);
}
/**
* Set value
*
* @param \google\api\AuthenticationRule $value
* @return \google\api\Authentication
*/
public function setRules(\google\api\AuthenticationRule $value, $idx = NULL){
return $this->_set(3, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\AuthenticationRule[]
*/
public function getRulesList(){
return $this->_get(3);
}
/**
* Add a new element to
*
* @param \google\api\AuthenticationRule $value
* @return \google\api\Authentication
*/
public function addRules(\google\api\AuthenticationRule $value){
return $this->_add(3, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasProviders(){
return $this->_has(4);
}
/**
* Clear value
*
* @return \google\api\Authentication
*/
public function clearProviders(){
return $this->_clear(4);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\AuthProvider
*/
public function getProviders($idx = NULL){
return $this->_get(4, $idx);
}
/**
* Set value
*
* @param \google\api\AuthProvider $value
* @return \google\api\Authentication
*/
public function setProviders(\google\api\AuthProvider $value, $idx = NULL){
return $this->_set(4, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\AuthProvider[]
*/
public function getProvidersList(){
return $this->_get(4);
}
/**
* Add a new element to
*
* @param \google\api\AuthProvider $value
* @return \google\api\Authentication
*/
public function addProviders(\google\api\AuthProvider $value){
return $this->_add(4, $value);
}
}
}
namespace google\api {
class AuthenticationRule extends \DrSlump\Protobuf\Message {
/** @var string */
public $selector = null;
/** @var \google\api\OAuthRequirements */
public $oauth = null;
/** @var boolean */
public $allow_without_credential = null;
/** @var \google\api\AuthRequirement[] */
public $requirements = array();
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.AuthenticationRule');
// OPTIONAL STRING selector = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "selector";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL MESSAGE oauth = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "oauth";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\OAuthRequirements';
$descriptor->addField($f);
// OPTIONAL BOOL allow_without_credential = 5
$f = new \DrSlump\Protobuf\Field();
$f->number = 5;
$f->name = "allow_without_credential";
$f->type = \DrSlump\Protobuf::TYPE_BOOL;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// REPEATED MESSAGE requirements = 7
$f = new \DrSlump\Protobuf\Field();
$f->number = 7;
$f->name = "requirements";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\AuthRequirement';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasSelector(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\AuthenticationRule
*/
public function clearSelector(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getSelector(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\AuthenticationRule
*/
public function setSelector( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasOauth(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\AuthenticationRule
*/
public function clearOauth(){
return $this->_clear(2);
}
/**
* Get value
*
* @return \google\api\OAuthRequirements
*/
public function getOauth(){
return $this->_get(2);
}
/**
* Set value
*
* @param \google\api\OAuthRequirements $value
* @return \google\api\AuthenticationRule
*/
public function setOauth(\google\api\OAuthRequirements $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasAllowWithoutCredential(){
return $this->_has(5);
}
/**
* Clear value
*
* @return \google\api\AuthenticationRule
*/
public function clearAllowWithoutCredential(){
return $this->_clear(5);
}
/**
* Get value
*
* @return boolean
*/
public function getAllowWithoutCredential(){
return $this->_get(5);
}
/**
* Set value
*
* @param boolean $value
* @return \google\api\AuthenticationRule
*/
public function setAllowWithoutCredential( $value){
return $this->_set(5, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRequirements(){
return $this->_has(7);
}
/**
* Clear value
*
* @return \google\api\AuthenticationRule
*/
public function clearRequirements(){
return $this->_clear(7);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\AuthRequirement
*/
public function getRequirements($idx = NULL){
return $this->_get(7, $idx);
}
/**
* Set value
*
* @param \google\api\AuthRequirement $value
* @return \google\api\AuthenticationRule
*/
public function setRequirements(\google\api\AuthRequirement $value, $idx = NULL){
return $this->_set(7, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\AuthRequirement[]
*/
public function getRequirementsList(){
return $this->_get(7);
}
/**
* Add a new element to
*
* @param \google\api\AuthRequirement $value
* @return \google\api\AuthenticationRule
*/
public function addRequirements(\google\api\AuthRequirement $value){
return $this->_add(7, $value);
}
}
}
namespace google\api {
class AuthProvider extends \DrSlump\Protobuf\Message {
/** @var string */
public $id = null;
/** @var string */
public $issuer = null;
/** @var string */
public $jwks_uri = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.AuthProvider');
// OPTIONAL STRING id = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "id";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL STRING issuer = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "issuer";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL STRING jwks_uri = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "jwks_uri";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasId(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\AuthProvider
*/
public function clearId(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getId(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\AuthProvider
*/
public function setId( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasIssuer(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\AuthProvider
*/
public function clearIssuer(){
return $this->_clear(2);
}
/**
* Get value
*
* @return string
*/
public function getIssuer(){
return $this->_get(2);
}
/**
* Set value
*
* @param string $value
* @return \google\api\AuthProvider
*/
public function setIssuer( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasJwksUri(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\AuthProvider
*/
public function clearJwksUri(){
return $this->_clear(3);
}
/**
* Get value
*
* @return string
*/
public function getJwksUri(){
return $this->_get(3);
}
/**
* Set value
*
* @param string $value
* @return \google\api\AuthProvider
*/
public function setJwksUri( $value){
return $this->_set(3, $value);
}
}
}
namespace google\api {
class OAuthRequirements extends \DrSlump\Protobuf\Message {
/** @var string */
public $canonical_scopes = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.OAuthRequirements');
// OPTIONAL STRING canonical_scopes = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "canonical_scopes";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasCanonicalScopes(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\OAuthRequirements
*/
public function clearCanonicalScopes(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getCanonicalScopes(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\OAuthRequirements
*/
public function setCanonicalScopes( $value){
return $this->_set(1, $value);
}
}
}
namespace google\api {
class AuthRequirement extends \DrSlump\Protobuf\Message {
/** @var string */
public $provider_id = null;
/** @var string */
public $audiences = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.AuthRequirement');
// OPTIONAL STRING provider_id = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "provider_id";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL STRING audiences = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "audiences";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasProviderId(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\AuthRequirement
*/
public function clearProviderId(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getProviderId(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\AuthRequirement
*/
public function setProviderId( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasAudiences(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\AuthRequirement
*/
public function clearAudiences(){
return $this->_clear(2);
}
/**
* Get value
*
* @return string
*/
public function getAudiences(){
return $this->_get(2);
}
/**
* Set value
*
* @param string $value
* @return \google\api\AuthRequirement
*/
public function setAudiences( $value){
return $this->_set(2, $value);
}
}
}
src/generated/backend.php 0000644 00000013021 15174273455 0011403 0 ustar 00 number = 1;
$f->name = "rules";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\BackendRule';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRules(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Backend
*/
public function clearRules(){
return $this->_clear(1);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\BackendRule
*/
public function getRules($idx = NULL){
return $this->_get(1, $idx);
}
/**
* Set value
*
* @param \google\api\BackendRule $value
* @return \google\api\Backend
*/
public function setRules(\google\api\BackendRule $value, $idx = NULL){
return $this->_set(1, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\BackendRule[]
*/
public function getRulesList(){
return $this->_get(1);
}
/**
* Add a new element to
*
* @param \google\api\BackendRule $value
* @return \google\api\Backend
*/
public function addRules(\google\api\BackendRule $value){
return $this->_add(1, $value);
}
}
}
namespace google\api {
class BackendRule extends \DrSlump\Protobuf\Message {
/** @var string */
public $selector = null;
/** @var string */
public $address = null;
/** @var float */
public $deadline = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.BackendRule');
// OPTIONAL STRING selector = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "selector";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL STRING address = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "address";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE deadline = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "deadline";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasSelector(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\BackendRule
*/
public function clearSelector(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getSelector(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\BackendRule
*/
public function setSelector( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasAddress(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\BackendRule
*/
public function clearAddress(){
return $this->_clear(2);
}
/**
* Get value
*
* @return string
*/
public function getAddress(){
return $this->_get(2);
}
/**
* Set value
*
* @param string $value
* @return \google\api\BackendRule
*/
public function setAddress( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasDeadline(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\BackendRule
*/
public function clearDeadline(){
return $this->_clear(3);
}
/**
* Get value
*
* @return float
*/
public function getDeadline(){
return $this->_get(3);
}
/**
* Set value
*
* @param float $value
* @return \google\api\BackendRule
*/
public function setDeadline( $value){
return $this->_set(3, $value);
}
}
}
src/generated/billing.php 0000644 00000015114 15174273455 0011441 0 ustar 00 number = 1;
$f->name = "metrics";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$descriptor->addField($f);
// REPEATED MESSAGE rules = 5
$f = new \DrSlump\Protobuf\Field();
$f->number = 5;
$f->name = "rules";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\BillingStatusRule';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasMetrics(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Billing
*/
public function clearMetrics(){
return $this->_clear(1);
}
/**
* Get value
*
* @param int $idx
* @return string
*/
public function getMetrics($idx = NULL){
return $this->_get(1, $idx);
}
/**
* Set value
*
* @param string $value
* @return \google\api\Billing
*/
public function setMetrics( $value, $idx = NULL){
return $this->_set(1, $value, $idx);
}
/**
* Get all elements of
*
* @return string[]
*/
public function getMetricsList(){
return $this->_get(1);
}
/**
* Add a new element to
*
* @param string $value
* @return \google\api\Billing
*/
public function addMetrics( $value){
return $this->_add(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRules(){
return $this->_has(5);
}
/**
* Clear value
*
* @return \google\api\Billing
*/
public function clearRules(){
return $this->_clear(5);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\BillingStatusRule
*/
public function getRules($idx = NULL){
return $this->_get(5, $idx);
}
/**
* Set value
*
* @param \google\api\BillingStatusRule $value
* @return \google\api\Billing
*/
public function setRules(\google\api\BillingStatusRule $value, $idx = NULL){
return $this->_set(5, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\BillingStatusRule[]
*/
public function getRulesList(){
return $this->_get(5);
}
/**
* Add a new element to
*
* @param \google\api\BillingStatusRule $value
* @return \google\api\Billing
*/
public function addRules(\google\api\BillingStatusRule $value){
return $this->_add(5, $value);
}
}
}
namespace google\api {
class BillingStatusRule extends \DrSlump\Protobuf\Message {
/** @var string */
public $selector = null;
/** @var string[] */
public $allowed_statuses = array();
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.BillingStatusRule');
// OPTIONAL STRING selector = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "selector";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// REPEATED STRING allowed_statuses = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "allowed_statuses";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasSelector(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\BillingStatusRule
*/
public function clearSelector(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getSelector(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\BillingStatusRule
*/
public function setSelector( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasAllowedStatuses(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\BillingStatusRule
*/
public function clearAllowedStatuses(){
return $this->_clear(2);
}
/**
* Get value
*
* @param int $idx
* @return string
*/
public function getAllowedStatuses($idx = NULL){
return $this->_get(2, $idx);
}
/**
* Set value
*
* @param string $value
* @return \google\api\BillingStatusRule
*/
public function setAllowedStatuses( $value, $idx = NULL){
return $this->_set(2, $value, $idx);
}
/**
* Get all elements of
*
* @return string[]
*/
public function getAllowedStatusesList(){
return $this->_get(2);
}
/**
* Add a new element to
*
* @param string $value
* @return \google\api\BillingStatusRule
*/
public function addAllowedStatuses( $value){
return $this->_add(2, $value);
}
}
}
src/generated/code.php 0000644 00000001261 15174273455 0010731 0 ustar 00 number = 1;
$f->name = "red";
$f->type = \DrSlump\Protobuf::TYPE_FLOAT;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL FLOAT green = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "green";
$f->type = \DrSlump\Protobuf::TYPE_FLOAT;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL FLOAT blue = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "blue";
$f->type = \DrSlump\Protobuf::TYPE_FLOAT;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL MESSAGE alpha = 4
$f = new \DrSlump\Protobuf\Field();
$f->number = 4;
$f->name = "alpha";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\protobuf\FloatValue';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRed(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\type\Color
*/
public function clearRed(){
return $this->_clear(1);
}
/**
* Get value
*
* @return float
*/
public function getRed(){
return $this->_get(1);
}
/**
* Set value
*
* @param float $value
* @return \google\type\Color
*/
public function setRed( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasGreen(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\type\Color
*/
public function clearGreen(){
return $this->_clear(2);
}
/**
* Get value
*
* @return float
*/
public function getGreen(){
return $this->_get(2);
}
/**
* Set value
*
* @param float $value
* @return \google\type\Color
*/
public function setGreen( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasBlue(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\type\Color
*/
public function clearBlue(){
return $this->_clear(3);
}
/**
* Get value
*
* @return float
*/
public function getBlue(){
return $this->_get(3);
}
/**
* Set value
*
* @param float $value
* @return \google\type\Color
*/
public function setBlue( $value){
return $this->_set(3, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasAlpha(){
return $this->_has(4);
}
/**
* Clear value
*
* @return \google\type\Color
*/
public function clearAlpha(){
return $this->_clear(4);
}
/**
* Get value
*
* @return \google\protobuf\FloatValue
*/
public function getAlpha(){
return $this->_get(4);
}
/**
* Set value
*
* @param \google\protobuf\FloatValue $value
* @return \google\type\Color
*/
public function setAlpha(\google\protobuf\FloatValue $value){
return $this->_set(4, $value);
}
}
}
src/generated/consumer.php 0000644 00000013635 15174273455 0011662 0 ustar 00 number = 1;
$f->name = "properties";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\Property';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasProperties(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\ProjectProperties
*/
public function clearProperties(){
return $this->_clear(1);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\Property
*/
public function getProperties($idx = NULL){
return $this->_get(1, $idx);
}
/**
* Set value
*
* @param \google\api\Property $value
* @return \google\api\ProjectProperties
*/
public function setProperties(\google\api\Property $value, $idx = NULL){
return $this->_set(1, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\Property[]
*/
public function getPropertiesList(){
return $this->_get(1);
}
/**
* Add a new element to
*
* @param \google\api\Property $value
* @return \google\api\ProjectProperties
*/
public function addProperties(\google\api\Property $value){
return $this->_add(1, $value);
}
}
}
namespace google\api\Property {
class PropertyType extends \DrSlump\Protobuf\Enum {
const UNSPECIFIED = 0;
const INT64 = 1;
const BOOL = 2;
const STRING = 3;
const DOUBLE = 4;
}
}
namespace google\api {
class Property extends \DrSlump\Protobuf\Message {
/** @var string */
public $name = null;
/** @var int - \google\api\Property\PropertyType */
public $type = null;
/** @var string */
public $description = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.Property');
// OPTIONAL STRING name = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "name";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL ENUM type = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "type";
$f->type = \DrSlump\Protobuf::TYPE_ENUM;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\Property\PropertyType';
$descriptor->addField($f);
// OPTIONAL STRING description = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "description";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasName(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Property
*/
public function clearName(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getName(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\Property
*/
public function setName( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasType(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\Property
*/
public function clearType(){
return $this->_clear(2);
}
/**
* Get value
*
* @return int - \google\api\Property\PropertyType
*/
public function getType(){
return $this->_get(2);
}
/**
* Set value
*
* @param int - \google\api\Property\PropertyType $value
* @return \google\api\Property
*/
public function setType( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasDescription(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\Property
*/
public function clearDescription(){
return $this->_clear(3);
}
/**
* Get value
*
* @return string
*/
public function getDescription(){
return $this->_get(3);
}
/**
* Set value
*
* @param string $value
* @return \google\api\Property
*/
public function setDescription( $value){
return $this->_set(3, $value);
}
}
}
src/generated/context.php 0000644 00000014652 15174273455 0011513 0 ustar 00 number = 1;
$f->name = "rules";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\ContextRule';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRules(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Context
*/
public function clearRules(){
return $this->_clear(1);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\ContextRule
*/
public function getRules($idx = NULL){
return $this->_get(1, $idx);
}
/**
* Set value
*
* @param \google\api\ContextRule $value
* @return \google\api\Context
*/
public function setRules(\google\api\ContextRule $value, $idx = NULL){
return $this->_set(1, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\ContextRule[]
*/
public function getRulesList(){
return $this->_get(1);
}
/**
* Add a new element to
*
* @param \google\api\ContextRule $value
* @return \google\api\Context
*/
public function addRules(\google\api\ContextRule $value){
return $this->_add(1, $value);
}
}
}
namespace google\api {
class ContextRule extends \DrSlump\Protobuf\Message {
/** @var string */
public $selector = null;
/** @var string[] */
public $requested = array();
/** @var string[] */
public $provided = array();
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.ContextRule');
// OPTIONAL STRING selector = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "selector";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// REPEATED STRING requested = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "requested";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$descriptor->addField($f);
// REPEATED STRING provided = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "provided";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasSelector(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\ContextRule
*/
public function clearSelector(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getSelector(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\ContextRule
*/
public function setSelector( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRequested(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\ContextRule
*/
public function clearRequested(){
return $this->_clear(2);
}
/**
* Get value
*
* @param int $idx
* @return string
*/
public function getRequested($idx = NULL){
return $this->_get(2, $idx);
}
/**
* Set value
*
* @param string $value
* @return \google\api\ContextRule
*/
public function setRequested( $value, $idx = NULL){
return $this->_set(2, $value, $idx);
}
/**
* Get all elements of
*
* @return string[]
*/
public function getRequestedList(){
return $this->_get(2);
}
/**
* Add a new element to
*
* @param string $value
* @return \google\api\ContextRule
*/
public function addRequested( $value){
return $this->_add(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasProvided(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\ContextRule
*/
public function clearProvided(){
return $this->_clear(3);
}
/**
* Get value
*
* @param int $idx
* @return string
*/
public function getProvided($idx = NULL){
return $this->_get(3, $idx);
}
/**
* Set value
*
* @param string $value
* @return \google\api\ContextRule
*/
public function setProvided( $value, $idx = NULL){
return $this->_set(3, $value, $idx);
}
/**
* Get all elements of
*
* @return string[]
*/
public function getProvidedList(){
return $this->_get(3);
}
/**
* Add a new element to
*
* @param string $value
* @return \google\api\ContextRule
*/
public function addProvided( $value){
return $this->_add(3, $value);
}
}
}
src/generated/control.php 0000644 00000003106 15174273455 0011477 0 ustar 00 number = 1;
$f->name = "environment";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasEnvironment(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Control
*/
public function clearEnvironment(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getEnvironment(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\Control
*/
public function setEnvironment( $value){
return $this->_set(1, $value);
}
}
}
src/generated/date.php 0000644 00000006546 15174273455 0010747 0 ustar 00 number = 1;
$f->name = "year";
$f->type = \DrSlump\Protobuf::TYPE_INT32;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL INT32 month = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "month";
$f->type = \DrSlump\Protobuf::TYPE_INT32;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL INT32 day = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "day";
$f->type = \DrSlump\Protobuf::TYPE_INT32;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasYear(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\type\Date
*/
public function clearYear(){
return $this->_clear(1);
}
/**
* Get value
*
* @return int
*/
public function getYear(){
return $this->_get(1);
}
/**
* Set value
*
* @param int $value
* @return \google\type\Date
*/
public function setYear( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasMonth(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\type\Date
*/
public function clearMonth(){
return $this->_clear(2);
}
/**
* Get value
*
* @return int
*/
public function getMonth(){
return $this->_get(2);
}
/**
* Set value
*
* @param int $value
* @return \google\type\Date
*/
public function setMonth( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasDay(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\type\Date
*/
public function clearDay(){
return $this->_clear(3);
}
/**
* Get value
*
* @return int
*/
public function getDay(){
return $this->_get(3);
}
/**
* Set value
*
* @param int $value
* @return \google\type\Date
*/
public function setDay( $value){
return $this->_set(3, $value);
}
}
}
src/generated/dayofweek.php 0000644 00000000644 15174273455 0012001 0 ustar 00 number = 1;
$f->name = "min";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE max = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "max";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasMin(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Distribution\Range
*/
public function clearMin(){
return $this->_clear(1);
}
/**
* Get value
*
* @return float
*/
public function getMin(){
return $this->_get(1);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\Range
*/
public function setMin( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasMax(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\Distribution\Range
*/
public function clearMax(){
return $this->_clear(2);
}
/**
* Get value
*
* @return float
*/
public function getMax(){
return $this->_get(2);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\Range
*/
public function setMax( $value){
return $this->_set(2, $value);
}
}
}
namespace google\api\Distribution\BucketOptions {
class Linear extends \DrSlump\Protobuf\Message {
/** @var int */
public $num_finite_buckets = null;
/** @var float */
public $width = null;
/** @var float */
public $offset = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.Distribution.BucketOptions.Linear');
// OPTIONAL INT32 num_finite_buckets = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "num_finite_buckets";
$f->type = \DrSlump\Protobuf::TYPE_INT32;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE width = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "width";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE offset = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "offset";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasNumFiniteBuckets(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function clearNumFiniteBuckets(){
return $this->_clear(1);
}
/**
* Get value
*
* @return int
*/
public function getNumFiniteBuckets(){
return $this->_get(1);
}
/**
* Set value
*
* @param int $value
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function setNumFiniteBuckets( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasWidth(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function clearWidth(){
return $this->_clear(2);
}
/**
* Get value
*
* @return float
*/
public function getWidth(){
return $this->_get(2);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function setWidth( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasOffset(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function clearOffset(){
return $this->_clear(3);
}
/**
* Get value
*
* @return float
*/
public function getOffset(){
return $this->_get(3);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function setOffset( $value){
return $this->_set(3, $value);
}
}
}
namespace google\api\Distribution\BucketOptions {
class Exponential extends \DrSlump\Protobuf\Message {
/** @var int */
public $num_finite_buckets = null;
/** @var float */
public $growth_factor = null;
/** @var float */
public $scale = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.Distribution.BucketOptions.Exponential');
// OPTIONAL INT32 num_finite_buckets = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "num_finite_buckets";
$f->type = \DrSlump\Protobuf::TYPE_INT32;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE growth_factor = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "growth_factor";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE scale = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "scale";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasNumFiniteBuckets(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function clearNumFiniteBuckets(){
return $this->_clear(1);
}
/**
* Get value
*
* @return int
*/
public function getNumFiniteBuckets(){
return $this->_get(1);
}
/**
* Set value
*
* @param int $value
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function setNumFiniteBuckets( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasGrowthFactor(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function clearGrowthFactor(){
return $this->_clear(2);
}
/**
* Get value
*
* @return float
*/
public function getGrowthFactor(){
return $this->_get(2);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function setGrowthFactor( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasScale(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function clearScale(){
return $this->_clear(3);
}
/**
* Get value
*
* @return float
*/
public function getScale(){
return $this->_get(3);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function setScale( $value){
return $this->_set(3, $value);
}
}
}
namespace google\api\Distribution\BucketOptions {
class Explicit extends \DrSlump\Protobuf\Message {
/** @var float[] */
public $bounds = array();
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.Distribution.BucketOptions.Explicit');
// REPEATED DOUBLE bounds = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "bounds";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasBounds(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions\Explicit
*/
public function clearBounds(){
return $this->_clear(1);
}
/**
* Get value
*
* @param int $idx
* @return float
*/
public function getBounds($idx = NULL){
return $this->_get(1, $idx);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution\BucketOptions\Explicit
*/
public function setBounds( $value, $idx = NULL){
return $this->_set(1, $value, $idx);
}
/**
* Get all elements of
*
* @return float[]
*/
public function getBoundsList(){
return $this->_get(1);
}
/**
* Add a new element to
*
* @param float $value
* @return \google\api\Distribution\BucketOptions\Explicit
*/
public function addBounds( $value){
return $this->_add(1, $value);
}
}
}
namespace google\api\Distribution {
class BucketOptions extends \DrSlump\Protobuf\Message {
/** @var \google\api\Distribution\BucketOptions\Linear */
public $linear_buckets = null;
/** @var \google\api\Distribution\BucketOptions\Exponential */
public $exponential_buckets = null;
/** @var \google\api\Distribution\BucketOptions\Explicit */
public $explicit_buckets = null;
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.Distribution.BucketOptions');
// OPTIONAL MESSAGE linear_buckets = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "linear_buckets";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\Distribution\BucketOptions\Linear';
$descriptor->addField($f);
// OPTIONAL MESSAGE exponential_buckets = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "exponential_buckets";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\Distribution\BucketOptions\Exponential';
$descriptor->addField($f);
// OPTIONAL MESSAGE explicit_buckets = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "explicit_buckets";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\Distribution\BucketOptions\Explicit';
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasLinearBuckets(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions
*/
public function clearLinearBuckets(){
return $this->_clear(1);
}
/**
* Get value
*
* @return \google\api\Distribution\BucketOptions\Linear
*/
public function getLinearBuckets(){
return $this->_get(1);
}
/**
* Set value
*
* @param \google\api\Distribution\BucketOptions\Linear $value
* @return \google\api\Distribution\BucketOptions
*/
public function setLinearBuckets(\google\api\Distribution\BucketOptions\Linear $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasExponentialBuckets(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions
*/
public function clearExponentialBuckets(){
return $this->_clear(2);
}
/**
* Get value
*
* @return \google\api\Distribution\BucketOptions\Exponential
*/
public function getExponentialBuckets(){
return $this->_get(2);
}
/**
* Set value
*
* @param \google\api\Distribution\BucketOptions\Exponential $value
* @return \google\api\Distribution\BucketOptions
*/
public function setExponentialBuckets(\google\api\Distribution\BucketOptions\Exponential $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasExplicitBuckets(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\Distribution\BucketOptions
*/
public function clearExplicitBuckets(){
return $this->_clear(3);
}
/**
* Get value
*
* @return \google\api\Distribution\BucketOptions\Explicit
*/
public function getExplicitBuckets(){
return $this->_get(3);
}
/**
* Set value
*
* @param \google\api\Distribution\BucketOptions\Explicit $value
* @return \google\api\Distribution\BucketOptions
*/
public function setExplicitBuckets(\google\api\Distribution\BucketOptions\Explicit $value){
return $this->_set(3, $value);
}
}
}
namespace google\api {
class Distribution extends \DrSlump\Protobuf\Message {
/** @var int */
public $count = null;
/** @var float */
public $mean = null;
/** @var float */
public $sum_of_squared_deviation = null;
/** @var \google\api\Distribution\Range */
public $range = null;
/** @var \google\api\Distribution\BucketOptions */
public $bucket_options = null;
/** @var int[] */
public $bucket_counts = array();
/** @var \Closure[] */
protected static $__extensions = array();
public static function descriptor()
{
$descriptor = new \DrSlump\Protobuf\Descriptor(__CLASS__, 'google.api.Distribution');
// OPTIONAL INT64 count = 1
$f = new \DrSlump\Protobuf\Field();
$f->number = 1;
$f->name = "count";
$f->type = \DrSlump\Protobuf::TYPE_INT64;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE mean = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "mean";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL DOUBLE sum_of_squared_deviation = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "sum_of_squared_deviation";
$f->type = \DrSlump\Protobuf::TYPE_DOUBLE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL MESSAGE range = 4
$f = new \DrSlump\Protobuf\Field();
$f->number = 4;
$f->name = "range";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\Distribution\Range';
$descriptor->addField($f);
// OPTIONAL MESSAGE bucket_options = 6
$f = new \DrSlump\Protobuf\Field();
$f->number = 6;
$f->name = "bucket_options";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$f->reference = '\google\api\Distribution\BucketOptions';
$descriptor->addField($f);
// REPEATED INT64 bucket_counts = 7
$f = new \DrSlump\Protobuf\Field();
$f->number = 7;
$f->name = "bucket_counts";
$f->type = \DrSlump\Protobuf::TYPE_INT64;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasCount(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Distribution
*/
public function clearCount(){
return $this->_clear(1);
}
/**
* Get value
*
* @return int
*/
public function getCount(){
return $this->_get(1);
}
/**
* Set value
*
* @param int $value
* @return \google\api\Distribution
*/
public function setCount( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasMean(){
return $this->_has(2);
}
/**
* Clear value
*
* @return \google\api\Distribution
*/
public function clearMean(){
return $this->_clear(2);
}
/**
* Get value
*
* @return float
*/
public function getMean(){
return $this->_get(2);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution
*/
public function setMean( $value){
return $this->_set(2, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasSumOfSquaredDeviation(){
return $this->_has(3);
}
/**
* Clear value
*
* @return \google\api\Distribution
*/
public function clearSumOfSquaredDeviation(){
return $this->_clear(3);
}
/**
* Get value
*
* @return float
*/
public function getSumOfSquaredDeviation(){
return $this->_get(3);
}
/**
* Set value
*
* @param float $value
* @return \google\api\Distribution
*/
public function setSumOfSquaredDeviation( $value){
return $this->_set(3, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasRange(){
return $this->_has(4);
}
/**
* Clear value
*
* @return \google\api\Distribution
*/
public function clearRange(){
return $this->_clear(4);
}
/**
* Get value
*
* @return \google\api\Distribution\Range
*/
public function getRange(){
return $this->_get(4);
}
/**
* Set value
*
* @param \google\api\Distribution\Range $value
* @return \google\api\Distribution
*/
public function setRange(\google\api\Distribution\Range $value){
return $this->_set(4, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasBucketOptions(){
return $this->_has(6);
}
/**
* Clear value
*
* @return \google\api\Distribution
*/
public function clearBucketOptions(){
return $this->_clear(6);
}
/**
* Get value
*
* @return \google\api\Distribution\BucketOptions
*/
public function getBucketOptions(){
return $this->_get(6);
}
/**
* Set value
*
* @param \google\api\Distribution\BucketOptions $value
* @return \google\api\Distribution
*/
public function setBucketOptions(\google\api\Distribution\BucketOptions $value){
return $this->_set(6, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasBucketCounts(){
return $this->_has(7);
}
/**
* Clear value
*
* @return \google\api\Distribution
*/
public function clearBucketCounts(){
return $this->_clear(7);
}
/**
* Get value
*
* @param int $idx
* @return int
*/
public function getBucketCounts($idx = NULL){
return $this->_get(7, $idx);
}
/**
* Set value
*
* @param int $value
* @return \google\api\Distribution
*/
public function setBucketCounts( $value, $idx = NULL){
return $this->_set(7, $value, $idx);
}
/**
* Get all elements of
*
* @return int[]
*/
public function getBucketCountsList(){
return $this->_get(7);
}
/**
* Add a new element to
*
* @param int $value
* @return \google\api\Distribution
*/
public function addBucketCounts( $value){
return $this->_add(7, $value);
}
}
}
src/generated/documentation.php 0000644 00000034632 15174273455 0012700 0 ustar 00 number = 1;
$f->name = "summary";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// REPEATED MESSAGE pages = 5
$f = new \DrSlump\Protobuf\Field();
$f->number = 5;
$f->name = "pages";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\Page';
$descriptor->addField($f);
// REPEATED MESSAGE rules = 3
$f = new \DrSlump\Protobuf\Field();
$f->number = 3;
$f->name = "rules";
$f->type = \DrSlump\Protobuf::TYPE_MESSAGE;
$f->rule = \DrSlump\Protobuf::RULE_REPEATED;
$f->reference = '\google\api\DocumentationRule';
$descriptor->addField($f);
// OPTIONAL STRING documentation_root_url = 4
$f = new \DrSlump\Protobuf\Field();
$f->number = 4;
$f->name = "documentation_root_url";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
// OPTIONAL STRING overview = 2
$f = new \DrSlump\Protobuf\Field();
$f->number = 2;
$f->name = "overview";
$f->type = \DrSlump\Protobuf::TYPE_STRING;
$f->rule = \DrSlump\Protobuf::RULE_OPTIONAL;
$descriptor->addField($f);
foreach (self::$__extensions as $cb) {
$descriptor->addField($cb(), true);
}
return $descriptor;
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasSummary(){
return $this->_has(1);
}
/**
* Clear value
*
* @return \google\api\Documentation
*/
public function clearSummary(){
return $this->_clear(1);
}
/**
* Get value
*
* @return string
*/
public function getSummary(){
return $this->_get(1);
}
/**
* Set value
*
* @param string $value
* @return \google\api\Documentation
*/
public function setSummary( $value){
return $this->_set(1, $value);
}
/**
* Check if has a value
*
* @return boolean
*/
public function hasPages(){
return $this->_has(5);
}
/**
* Clear value
*
* @return \google\api\Documentation
*/
public function clearPages(){
return $this->_clear(5);
}
/**
* Get value
*
* @param int $idx
* @return \google\api\Page
*/
public function getPages($idx = NULL){
return $this->_get(5, $idx);
}
/**
* Set value
*
* @param \google\api\Page $value
* @return \google\api\Documentation
*/
public function setPages(\google\api\Page $value, $idx = NULL){
return $this->_set(5, $value, $idx);
}
/**
* Get all elements of
*
* @return \google\api\Page[]
*/
public function getPagesList(){
return $this->_get(5);
}
/**
* Add a new element to
*
* @param \google\api\Page $value
* @return \google\api\Documentation
*/
public function addPages(\google\api\Page $value){
return $this->_add(5, $value);
}
/**
* Check if