Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 3.10.x will end 8 November 2021 (12 months).
  • Bug fixes for security issues in 3.10.x will end 9 May 2022 (18 months).
  • PHP version: minimum PHP 7.2.0 Note: minimum PHP version has increased since Moodle 3.8. PHP 7.3.x and 7.4.x are supported too.

Differences Between: [Versions 310 and 402] [Versions 310 and 403]

   1  <?php
   2  /*
   3   * Copyright 2010 Google Inc.
   4   *
   5   * Licensed under the Apache License, Version 2.0 (the "License"); you may not
   6   * use this file except in compliance with the License. You may obtain a copy of
   7   * the License at
   8   *
   9   * http://www.apache.org/licenses/LICENSE-2.0
  10   *
  11   * Unless required by applicable law or agreed to in writing, software
  12   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  13   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  14   * License for the specific language governing permissions and limitations under
  15   * the License.
  16   */
  17  
  18  /**
  19   * Service definition for Clouddebugger (v2).
  20   *
  21   * <p>
  22   * Lets you examine the stack and variables of your running application without
  23   * stopping or slowing it down.</p>
  24   *
  25   * <p>
  26   * For more information about this service, see the API
  27   * <a href="https://cloud.google.com/tools/cloud-debugger" target="_blank">Documentation</a>
  28   * </p>
  29   *
  30   * @author Google, Inc.
  31   */
  32  class Google_Service_Clouddebugger extends Google_Service
  33  {
  34    /** View and manage your data across Google Cloud Platform services. */
  35    const CLOUD_PLATFORM =
  36        "https://www.googleapis.com/auth/cloud-platform";
  37    /** Manage cloud debugger. */
  38    const CLOUD_DEBUGGER =
  39        "https://www.googleapis.com/auth/cloud_debugger";
  40    /** Manage active breakpoints in cloud debugger. */
  41    const CLOUD_DEBUGLETCONTROLLER =
  42        "https://www.googleapis.com/auth/cloud_debugletcontroller";
  43  
  44    public $controller_debuggees;
  45    public $controller_debuggees_breakpoints;
  46    public $debugger_debuggees;
  47    public $debugger_debuggees_breakpoints;
  48    
  49  
  50    /**
  51     * Constructs the internal representation of the Clouddebugger service.
  52     *
  53     * @param Google_Client $client
  54     */
  55    public function __construct(Google_Client $client)
  56    {
  57      parent::__construct($client);
  58      $this->rootUrl = 'https://clouddebugger.googleapis.com/';
  59      $this->servicePath = '';
  60      $this->version = 'v2';
  61      $this->serviceName = 'clouddebugger';
  62  
  63      $this->controller_debuggees = new Google_Service_Clouddebugger_ControllerDebuggees_Resource(
  64          $this,
  65          $this->serviceName,
  66          'debuggees',
  67          array(
  68            'methods' => array(
  69              'register' => array(
  70                'path' => 'v2/controller/debuggees/register',
  71                'httpMethod' => 'POST',
  72                'parameters' => array(),
  73              ),
  74            )
  75          )
  76      );
  77      $this->controller_debuggees_breakpoints = new Google_Service_Clouddebugger_ControllerDebuggeesBreakpoints_Resource(
  78          $this,
  79          $this->serviceName,
  80          'breakpoints',
  81          array(
  82            'methods' => array(
  83              'list' => array(
  84                'path' => 'v2/controller/debuggees/{debuggeeId}/breakpoints',
  85                'httpMethod' => 'GET',
  86                'parameters' => array(
  87                  'debuggeeId' => array(
  88                    'location' => 'path',
  89                    'type' => 'string',
  90                    'required' => true,
  91                  ),
  92                  'waitToken' => array(
  93                    'location' => 'query',
  94                    'type' => 'string',
  95                  ),
  96                ),
  97              ),'update' => array(
  98                'path' => 'v2/controller/debuggees/{debuggeeId}/breakpoints/{id}',
  99                'httpMethod' => 'PUT',
 100                'parameters' => array(
 101                  'debuggeeId' => array(
 102                    'location' => 'path',
 103                    'type' => 'string',
 104                    'required' => true,
 105                  ),
 106                  'id' => array(
 107                    'location' => 'path',
 108                    'type' => 'string',
 109                    'required' => true,
 110                  ),
 111                ),
 112              ),
 113            )
 114          )
 115      );
 116      $this->debugger_debuggees = new Google_Service_Clouddebugger_DebuggerDebuggees_Resource(
 117          $this,
 118          $this->serviceName,
 119          'debuggees',
 120          array(
 121            'methods' => array(
 122              'list' => array(
 123                'path' => 'v2/debugger/debuggees',
 124                'httpMethod' => 'GET',
 125                'parameters' => array(
 126                  'project' => array(
 127                    'location' => 'query',
 128                    'type' => 'string',
 129                  ),
 130                  'includeInactive' => array(
 131                    'location' => 'query',
 132                    'type' => 'boolean',
 133                  ),
 134                ),
 135              ),
 136            )
 137          )
 138      );
 139      $this->debugger_debuggees_breakpoints = new Google_Service_Clouddebugger_DebuggerDebuggeesBreakpoints_Resource(
 140          $this,
 141          $this->serviceName,
 142          'breakpoints',
 143          array(
 144            'methods' => array(
 145              'delete' => array(
 146                'path' => 'v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}',
 147                'httpMethod' => 'DELETE',
 148                'parameters' => array(
 149                  'debuggeeId' => array(
 150                    'location' => 'path',
 151                    'type' => 'string',
 152                    'required' => true,
 153                  ),
 154                  'breakpointId' => array(
 155                    'location' => 'path',
 156                    'type' => 'string',
 157                    'required' => true,
 158                  ),
 159                ),
 160              ),'get' => array(
 161                'path' => 'v2/debugger/debuggees/{debuggeeId}/breakpoints/{breakpointId}',
 162                'httpMethod' => 'GET',
 163                'parameters' => array(
 164                  'debuggeeId' => array(
 165                    'location' => 'path',
 166                    'type' => 'string',
 167                    'required' => true,
 168                  ),
 169                  'breakpointId' => array(
 170                    'location' => 'path',
 171                    'type' => 'string',
 172                    'required' => true,
 173                  ),
 174                ),
 175              ),'list' => array(
 176                'path' => 'v2/debugger/debuggees/{debuggeeId}/breakpoints',
 177                'httpMethod' => 'GET',
 178                'parameters' => array(
 179                  'debuggeeId' => array(
 180                    'location' => 'path',
 181                    'type' => 'string',
 182                    'required' => true,
 183                  ),
 184                  'includeAllUsers' => array(
 185                    'location' => 'query',
 186                    'type' => 'boolean',
 187                  ),
 188                  'stripResults' => array(
 189                    'location' => 'query',
 190                    'type' => 'boolean',
 191                  ),
 192                  'action.value' => array(
 193                    'location' => 'query',
 194                    'type' => 'string',
 195                  ),
 196                  'includeInactive' => array(
 197                    'location' => 'query',
 198                    'type' => 'boolean',
 199                  ),
 200                  'waitToken' => array(
 201                    'location' => 'query',
 202                    'type' => 'string',
 203                  ),
 204                ),
 205              ),'set' => array(
 206                'path' => 'v2/debugger/debuggees/{debuggeeId}/breakpoints/set',
 207                'httpMethod' => 'POST',
 208                'parameters' => array(
 209                  'debuggeeId' => array(
 210                    'location' => 'path',
 211                    'type' => 'string',
 212                    'required' => true,
 213                  ),
 214                ),
 215              ),
 216            )
 217          )
 218      );
 219    }
 220  }
 221  
 222  
 223  /**
 224   * The "controller" collection of methods.
 225   * Typical usage is:
 226   *  <code>
 227   *   $clouddebuggerService = new Google_Service_Clouddebugger(...);
 228   *   $controller = $clouddebuggerService->controller;
 229   *  </code>
 230   */
 231  class Google_Service_Clouddebugger_Controller_Resource extends Google_Service_Resource
 232  {
 233  }
 234  
 235  /**
 236   * The "debuggees" collection of methods.
 237   * Typical usage is:
 238   *  <code>
 239   *   $clouddebuggerService = new Google_Service_Clouddebugger(...);
 240   *   $debuggees = $clouddebuggerService->debuggees;
 241   *  </code>
 242   */
 243  class Google_Service_Clouddebugger_ControllerDebuggees_Resource extends Google_Service_Resource
 244  {
 245  
 246    /**
 247     * Registers the debuggee with the controller. All agents should call this API
 248     * with the same request content to get back the same stable 'debuggee_id'.
 249     * Agents should call this API again whenever ListActiveBreakpoints or
 250     * UpdateActiveBreakpoint return the error google.rpc.Code.NOT_FOUND. It allows
 251     * the server to disable the agent or recover from any registration loss. If the
 252     * debuggee is disabled server, the response will have is_disabled' set to true.
 253     * (debuggees.register)
 254     *
 255     * @param Google_RegisterDebuggeeRequest $postBody
 256     * @param array $optParams Optional parameters.
 257     * @return Google_Service_Clouddebugger_RegisterDebuggeeResponse
 258     */
 259    public function register(Google_Service_Clouddebugger_RegisterDebuggeeRequest $postBody, $optParams = array())
 260    {
 261      $params = array('postBody' => $postBody);
 262      $params = array_merge($params, $optParams);
 263      return $this->call('register', array($params), "Google_Service_Clouddebugger_RegisterDebuggeeResponse");
 264    }
 265  }
 266  
 267  /**
 268   * The "breakpoints" collection of methods.
 269   * Typical usage is:
 270   *  <code>
 271   *   $clouddebuggerService = new Google_Service_Clouddebugger(...);
 272   *   $breakpoints = $clouddebuggerService->breakpoints;
 273   *  </code>
 274   */
 275  class Google_Service_Clouddebugger_ControllerDebuggeesBreakpoints_Resource extends Google_Service_Resource
 276  {
 277  
 278    /**
 279     * Returns the list of all active breakpoints for the specified debuggee. The
 280     * breakpoint specification (location, condition, and expression fields) is
 281     * semantically immutable, although the field values may change. For example, an
 282     * agent may update the location line number to reflect the actual line the
 283     * breakpoint was set to, but that doesn't change the breakpoint semantics.
 284     * Thus, an agent does not need to check if a breakpoint has changed when it
 285     * encounters the same breakpoint on a successive call. Moreover, an agent
 286     * should remember breakpoints that are complete until the controller removes
 287     * them from the active list to avoid setting those breakpoints again.
 288     * (breakpoints.listControllerDebuggeesBreakpoints)
 289     *
 290     * @param string $debuggeeId Identifies the debuggee.
 291     * @param array $optParams Optional parameters.
 292     *
 293     * @opt_param string waitToken A wait token that, if specified, blocks the
 294     * method call until the list of active breakpoints has changed, or a server
 295     * selected timeout has expired. The value should be set from the last returned
 296     * response. The error code google.rpc.Code.ABORTED is returned on wait timeout
 297     * (which does not require the agent to re-register with the server)
 298     * @return Google_Service_Clouddebugger_ListActiveBreakpointsResponse
 299     */
 300    public function listControllerDebuggeesBreakpoints($debuggeeId, $optParams = array())
 301    {
 302      $params = array('debuggeeId' => $debuggeeId);
 303      $params = array_merge($params, $optParams);
 304      return $this->call('list', array($params), "Google_Service_Clouddebugger_ListActiveBreakpointsResponse");
 305    }
 306  
 307    /**
 308     * Updates the breakpoint state or mutable fields. The entire Breakpoint
 309     * protobuf must be sent back to the controller. Updates to active breakpoint
 310     * fields are only allowed if the new value does not change the breakpoint
 311     * specification. Updates to the 'location', 'condition' and 'expression' fields
 312     * should not alter the breakpoint semantics. They are restricted to changes
 313     * such as canonicalizing a value or snapping the location to the correct line
 314     * of code. (breakpoints.update)
 315     *
 316     * @param string $debuggeeId Identifies the debuggee being debugged.
 317     * @param string $id Breakpoint identifier, unique in the scope of the debuggee.
 318     * @param Google_UpdateActiveBreakpointRequest $postBody
 319     * @param array $optParams Optional parameters.
 320     * @return Google_Service_Clouddebugger_UpdateActiveBreakpointResponse
 321     */
 322    public function update($debuggeeId, $id, Google_Service_Clouddebugger_UpdateActiveBreakpointRequest $postBody, $optParams = array())
 323    {
 324      $params = array('debuggeeId' => $debuggeeId, 'id' => $id, 'postBody' => $postBody);
 325      $params = array_merge($params, $optParams);
 326      return $this->call('update', array($params), "Google_Service_Clouddebugger_UpdateActiveBreakpointResponse");
 327    }
 328  }
 329  
 330  /**
 331   * The "debugger" collection of methods.
 332   * Typical usage is:
 333   *  <code>
 334   *   $clouddebuggerService = new Google_Service_Clouddebugger(...);
 335   *   $debugger = $clouddebuggerService->debugger;
 336   *  </code>
 337   */
 338  class Google_Service_Clouddebugger_Debugger_Resource extends Google_Service_Resource
 339  {
 340  }
 341  
 342  /**
 343   * The "debuggees" collection of methods.
 344   * Typical usage is:
 345   *  <code>
 346   *   $clouddebuggerService = new Google_Service_Clouddebugger(...);
 347   *   $debuggees = $clouddebuggerService->debuggees;
 348   *  </code>
 349   */
 350  class Google_Service_Clouddebugger_DebuggerDebuggees_Resource extends Google_Service_Resource
 351  {
 352  
 353    /**
 354     * Lists all the debuggees that the user can set breakpoints to.
 355     * (debuggees.listDebuggerDebuggees)
 356     *
 357     * @param array $optParams Optional parameters.
 358     *
 359     * @opt_param string project Set to the project number of the Google Cloud
 360     * Platform to list the debuggees that are part of that project.
 361     * @opt_param bool includeInactive When set to true the result includes all
 362     * debuggees, otherwise only debugees that are active.
 363     * @return Google_Service_Clouddebugger_ListDebuggeesResponse
 364     */
 365    public function listDebuggerDebuggees($optParams = array())
 366    {
 367      $params = array();
 368      $params = array_merge($params, $optParams);
 369      return $this->call('list', array($params), "Google_Service_Clouddebugger_ListDebuggeesResponse");
 370    }
 371  }
 372  
 373  /**
 374   * The "breakpoints" collection of methods.
 375   * Typical usage is:
 376   *  <code>
 377   *   $clouddebuggerService = new Google_Service_Clouddebugger(...);
 378   *   $breakpoints = $clouddebuggerService->breakpoints;
 379   *  </code>
 380   */
 381  class Google_Service_Clouddebugger_DebuggerDebuggeesBreakpoints_Resource extends Google_Service_Resource
 382  {
 383  
 384    /**
 385     * Deletes the breakpoint from the debuggee. (breakpoints.delete)
 386     *
 387     * @param string $debuggeeId The debuggee id to delete the breakpoint from.
 388     * @param string $breakpointId The breakpoint to delete.
 389     * @param array $optParams Optional parameters.
 390     * @return Google_Service_Clouddebugger_Empty
 391     */
 392    public function delete($debuggeeId, $breakpointId, $optParams = array())
 393    {
 394      $params = array('debuggeeId' => $debuggeeId, 'breakpointId' => $breakpointId);
 395      $params = array_merge($params, $optParams);
 396      return $this->call('delete', array($params), "Google_Service_Clouddebugger_Empty");
 397    }
 398  
 399    /**
 400     * Gets breakpoint information. (breakpoints.get)
 401     *
 402     * @param string $debuggeeId The debuggee id to get the breakpoint from.
 403     * @param string $breakpointId The breakpoint to get.
 404     * @param array $optParams Optional parameters.
 405     * @return Google_Service_Clouddebugger_GetBreakpointResponse
 406     */
 407    public function get($debuggeeId, $breakpointId, $optParams = array())
 408    {
 409      $params = array('debuggeeId' => $debuggeeId, 'breakpointId' => $breakpointId);
 410      $params = array_merge($params, $optParams);
 411      return $this->call('get', array($params), "Google_Service_Clouddebugger_GetBreakpointResponse");
 412    }
 413  
 414    /**
 415     * Lists all breakpoints of the debuggee that the user has access to.
 416     * (breakpoints.listDebuggerDebuggeesBreakpoints)
 417     *
 418     * @param string $debuggeeId The debuggee id to list breakpoint from.
 419     * @param array $optParams Optional parameters.
 420     *
 421     * @opt_param bool includeAllUsers When set to true the response includes the
 422     * list of breakpoints set by any user, otherwise only breakpoints set by the
 423     * caller.
 424     * @opt_param bool stripResults When set to true the response breakpoints will
 425     * be stripped of the results fields: stack_frames, evaluated_expressions and
 426     * variable_table.
 427     * @opt_param string action.value Only breakpoints with the specified action
 428     * will pass the filter.
 429     * @opt_param bool includeInactive When set to true the response includes active
 430     * and inactive breakpoints, otherwise only active breakpoints are returned.
 431     * @opt_param string waitToken A wait token that, if specified, blocks the call
 432     * until the breakpoints list has changed, or a server selected timeout has
 433     * expired. The value should be set from the last response to ListBreakpoints.
 434     * The error code ABORTED is returned on wait timeout, which should be called
 435     * again with the same wait_token.
 436     * @return Google_Service_Clouddebugger_ListBreakpointsResponse
 437     */
 438    public function listDebuggerDebuggeesBreakpoints($debuggeeId, $optParams = array())
 439    {
 440      $params = array('debuggeeId' => $debuggeeId);
 441      $params = array_merge($params, $optParams);
 442      return $this->call('list', array($params), "Google_Service_Clouddebugger_ListBreakpointsResponse");
 443    }
 444  
 445    /**
 446     * Sets the breakpoint to the debuggee. (breakpoints.set)
 447     *
 448     * @param string $debuggeeId The debuggee id to set the breakpoint to.
 449     * @param Google_Breakpoint $postBody
 450     * @param array $optParams Optional parameters.
 451     * @return Google_Service_Clouddebugger_SetBreakpointResponse
 452     */
 453    public function set($debuggeeId, Google_Service_Clouddebugger_Breakpoint $postBody, $optParams = array())
 454    {
 455      $params = array('debuggeeId' => $debuggeeId, 'postBody' => $postBody);
 456      $params = array_merge($params, $optParams);
 457      return $this->call('set', array($params), "Google_Service_Clouddebugger_SetBreakpointResponse");
 458    }
 459  }
 460  
 461  
 462  
 463  
 464  class Google_Service_Clouddebugger_Breakpoint extends Google_Collection
 465  {
 466    protected $collection_key = 'variableTable';
 467    protected $internal_gapi_mappings = array(
 468    );
 469    public $action;
 470    public $condition;
 471    public $createTime;
 472    protected $evaluatedExpressionsType = 'Google_Service_Clouddebugger_Variable';
 473    protected $evaluatedExpressionsDataType = 'array';
 474    public $expressions;
 475    public $finalTime;
 476    public $id;
 477    public $isFinalState;
 478    protected $locationType = 'Google_Service_Clouddebugger_SourceLocation';
 479    protected $locationDataType = '';
 480    public $logLevel;
 481    public $logMessageFormat;
 482    protected $stackFramesType = 'Google_Service_Clouddebugger_StackFrame';
 483    protected $stackFramesDataType = 'array';
 484    protected $statusType = 'Google_Service_Clouddebugger_StatusMessage';
 485    protected $statusDataType = '';
 486    public $userEmail;
 487    protected $variableTableType = 'Google_Service_Clouddebugger_Variable';
 488    protected $variableTableDataType = 'array';
 489  
 490  
 491    public function setAction($action)
 492    {
 493      $this->action = $action;
 494    }
 495    public function getAction()
 496    {
 497      return $this->action;
 498    }
 499    public function setCondition($condition)
 500    {
 501      $this->condition = $condition;
 502    }
 503    public function getCondition()
 504    {
 505      return $this->condition;
 506    }
 507    public function setCreateTime($createTime)
 508    {
 509      $this->createTime = $createTime;
 510    }
 511    public function getCreateTime()
 512    {
 513      return $this->createTime;
 514    }
 515    public function setEvaluatedExpressions($evaluatedExpressions)
 516    {
 517      $this->evaluatedExpressions = $evaluatedExpressions;
 518    }
 519    public function getEvaluatedExpressions()
 520    {
 521      return $this->evaluatedExpressions;
 522    }
 523    public function setExpressions($expressions)
 524    {
 525      $this->expressions = $expressions;
 526    }
 527    public function getExpressions()
 528    {
 529      return $this->expressions;
 530    }
 531    public function setFinalTime($finalTime)
 532    {
 533      $this->finalTime = $finalTime;
 534    }
 535    public function getFinalTime()
 536    {
 537      return $this->finalTime;
 538    }
 539    public function setId($id)
 540    {
 541      $this->id = $id;
 542    }
 543    public function getId()
 544    {
 545      return $this->id;
 546    }
 547    public function setIsFinalState($isFinalState)
 548    {
 549      $this->isFinalState = $isFinalState;
 550    }
 551    public function getIsFinalState()
 552    {
 553      return $this->isFinalState;
 554    }
 555    public function setLocation(Google_Service_Clouddebugger_SourceLocation $location)
 556    {
 557      $this->location = $location;
 558    }
 559    public function getLocation()
 560    {
 561      return $this->location;
 562    }
 563    public function setLogLevel($logLevel)
 564    {
 565      $this->logLevel = $logLevel;
 566    }
 567    public function getLogLevel()
 568    {
 569      return $this->logLevel;
 570    }
 571    public function setLogMessageFormat($logMessageFormat)
 572    {
 573      $this->logMessageFormat = $logMessageFormat;
 574    }
 575    public function getLogMessageFormat()
 576    {
 577      return $this->logMessageFormat;
 578    }
 579    public function setStackFrames($stackFrames)
 580    {
 581      $this->stackFrames = $stackFrames;
 582    }
 583    public function getStackFrames()
 584    {
 585      return $this->stackFrames;
 586    }
 587    public function setStatus(Google_Service_Clouddebugger_StatusMessage $status)
 588    {
 589      $this->status = $status;
 590    }
 591    public function getStatus()
 592    {
 593      return $this->status;
 594    }
 595    public function setUserEmail($userEmail)
 596    {
 597      $this->userEmail = $userEmail;
 598    }
 599    public function getUserEmail()
 600    {
 601      return $this->userEmail;
 602    }
 603    public function setVariableTable($variableTable)
 604    {
 605      $this->variableTable = $variableTable;
 606    }
 607    public function getVariableTable()
 608    {
 609      return $this->variableTable;
 610    }
 611  }
 612  
 613  class Google_Service_Clouddebugger_CloudRepoSourceContext extends Google_Model
 614  {
 615    protected $internal_gapi_mappings = array(
 616    );
 617    public $aliasName;
 618    protected $repoIdType = 'Google_Service_Clouddebugger_RepoId';
 619    protected $repoIdDataType = '';
 620    public $revisionId;
 621  
 622  
 623    public function setAliasName($aliasName)
 624    {
 625      $this->aliasName = $aliasName;
 626    }
 627    public function getAliasName()
 628    {
 629      return $this->aliasName;
 630    }
 631    public function setRepoId(Google_Service_Clouddebugger_RepoId $repoId)
 632    {
 633      $this->repoId = $repoId;
 634    }
 635    public function getRepoId()
 636    {
 637      return $this->repoId;
 638    }
 639    public function setRevisionId($revisionId)
 640    {
 641      $this->revisionId = $revisionId;
 642    }
 643    public function getRevisionId()
 644    {
 645      return $this->revisionId;
 646    }
 647  }
 648  
 649  class Google_Service_Clouddebugger_CloudWorkspaceId extends Google_Model
 650  {
 651    protected $internal_gapi_mappings = array(
 652    );
 653    public $name;
 654    protected $repoIdType = 'Google_Service_Clouddebugger_RepoId';
 655    protected $repoIdDataType = '';
 656  
 657  
 658    public function setName($name)
 659    {
 660      $this->name = $name;
 661    }
 662    public function getName()
 663    {
 664      return $this->name;
 665    }
 666    public function setRepoId(Google_Service_Clouddebugger_RepoId $repoId)
 667    {
 668      $this->repoId = $repoId;
 669    }
 670    public function getRepoId()
 671    {
 672      return $this->repoId;
 673    }
 674  }
 675  
 676  class Google_Service_Clouddebugger_CloudWorkspaceSourceContext extends Google_Model
 677  {
 678    protected $internal_gapi_mappings = array(
 679    );
 680    public $snapshotId;
 681    protected $workspaceIdType = 'Google_Service_Clouddebugger_CloudWorkspaceId';
 682    protected $workspaceIdDataType = '';
 683  
 684  
 685    public function setSnapshotId($snapshotId)
 686    {
 687      $this->snapshotId = $snapshotId;
 688    }
 689    public function getSnapshotId()
 690    {
 691      return $this->snapshotId;
 692    }
 693    public function setWorkspaceId(Google_Service_Clouddebugger_CloudWorkspaceId $workspaceId)
 694    {
 695      $this->workspaceId = $workspaceId;
 696    }
 697    public function getWorkspaceId()
 698    {
 699      return $this->workspaceId;
 700    }
 701  }
 702  
 703  class Google_Service_Clouddebugger_Debuggee extends Google_Collection
 704  {
 705    protected $collection_key = 'sourceContexts';
 706    protected $internal_gapi_mappings = array(
 707    );
 708    public $agentVersion;
 709    public $description;
 710    public $id;
 711    public $isDisabled;
 712    public $isInactive;
 713    public $labels;
 714    public $project;
 715    protected $sourceContextsType = 'Google_Service_Clouddebugger_SourceContext';
 716    protected $sourceContextsDataType = 'array';
 717    protected $statusType = 'Google_Service_Clouddebugger_StatusMessage';
 718    protected $statusDataType = '';
 719    public $uniquifier;
 720  
 721  
 722    public function setAgentVersion($agentVersion)
 723    {
 724      $this->agentVersion = $agentVersion;
 725    }
 726    public function getAgentVersion()
 727    {
 728      return $this->agentVersion;
 729    }
 730    public function setDescription($description)
 731    {
 732      $this->description = $description;
 733    }
 734    public function getDescription()
 735    {
 736      return $this->description;
 737    }
 738    public function setId($id)
 739    {
 740      $this->id = $id;
 741    }
 742    public function getId()
 743    {
 744      return $this->id;
 745    }
 746    public function setIsDisabled($isDisabled)
 747    {
 748      $this->isDisabled = $isDisabled;
 749    }
 750    public function getIsDisabled()
 751    {
 752      return $this->isDisabled;
 753    }
 754    public function setIsInactive($isInactive)
 755    {
 756      $this->isInactive = $isInactive;
 757    }
 758    public function getIsInactive()
 759    {
 760      return $this->isInactive;
 761    }
 762    public function setLabels($labels)
 763    {
 764      $this->labels = $labels;
 765    }
 766    public function getLabels()
 767    {
 768      return $this->labels;
 769    }
 770    public function setProject($project)
 771    {
 772      $this->project = $project;
 773    }
 774    public function getProject()
 775    {
 776      return $this->project;
 777    }
 778    public function setSourceContexts($sourceContexts)
 779    {
 780      $this->sourceContexts = $sourceContexts;
 781    }
 782    public function getSourceContexts()
 783    {
 784      return $this->sourceContexts;
 785    }
 786    public function setStatus(Google_Service_Clouddebugger_StatusMessage $status)
 787    {
 788      $this->status = $status;
 789    }
 790    public function getStatus()
 791    {
 792      return $this->status;
 793    }
 794    public function setUniquifier($uniquifier)
 795    {
 796      $this->uniquifier = $uniquifier;
 797    }
 798    public function getUniquifier()
 799    {
 800      return $this->uniquifier;
 801    }
 802  }
 803  
 804  class Google_Service_Clouddebugger_DebuggeeLabels extends Google_Model
 805  {
 806  }
 807  
 808  class Google_Service_Clouddebugger_Empty extends Google_Model
 809  {
 810  }
 811  
 812  class Google_Service_Clouddebugger_FormatMessage extends Google_Collection
 813  {
 814    protected $collection_key = 'parameters';
 815    protected $internal_gapi_mappings = array(
 816    );
 817    public $format;
 818    public $parameters;
 819  
 820  
 821    public function setFormat($format)
 822    {
 823      $this->format = $format;
 824    }
 825    public function getFormat()
 826    {
 827      return $this->format;
 828    }
 829    public function setParameters($parameters)
 830    {
 831      $this->parameters = $parameters;
 832    }
 833    public function getParameters()
 834    {
 835      return $this->parameters;
 836    }
 837  }
 838  
 839  class Google_Service_Clouddebugger_GerritSourceContext extends Google_Model
 840  {
 841    protected $internal_gapi_mappings = array(
 842    );
 843    public $aliasName;
 844    public $gerritProject;
 845    public $hostUri;
 846    public $revisionId;
 847  
 848  
 849    public function setAliasName($aliasName)
 850    {
 851      $this->aliasName = $aliasName;
 852    }
 853    public function getAliasName()
 854    {
 855      return $this->aliasName;
 856    }
 857    public function setGerritProject($gerritProject)
 858    {
 859      $this->gerritProject = $gerritProject;
 860    }
 861    public function getGerritProject()
 862    {
 863      return $this->gerritProject;
 864    }
 865    public function setHostUri($hostUri)
 866    {
 867      $this->hostUri = $hostUri;
 868    }
 869    public function getHostUri()
 870    {
 871      return $this->hostUri;
 872    }
 873    public function setRevisionId($revisionId)
 874    {
 875      $this->revisionId = $revisionId;
 876    }
 877    public function getRevisionId()
 878    {
 879      return $this->revisionId;
 880    }
 881  }
 882  
 883  class Google_Service_Clouddebugger_GetBreakpointResponse extends Google_Model
 884  {
 885    protected $internal_gapi_mappings = array(
 886    );
 887    protected $breakpointType = 'Google_Service_Clouddebugger_Breakpoint';
 888    protected $breakpointDataType = '';
 889  
 890  
 891    public function setBreakpoint(Google_Service_Clouddebugger_Breakpoint $breakpoint)
 892    {
 893      $this->breakpoint = $breakpoint;
 894    }
 895    public function getBreakpoint()
 896    {
 897      return $this->breakpoint;
 898    }
 899  }
 900  
 901  class Google_Service_Clouddebugger_GitSourceContext extends Google_Model
 902  {
 903    protected $internal_gapi_mappings = array(
 904    );
 905    public $revisionId;
 906    public $url;
 907  
 908  
 909    public function setRevisionId($revisionId)
 910    {
 911      $this->revisionId = $revisionId;
 912    }
 913    public function getRevisionId()
 914    {
 915      return $this->revisionId;
 916    }
 917    public function setUrl($url)
 918    {
 919      $this->url = $url;
 920    }
 921    public function getUrl()
 922    {
 923      return $this->url;
 924    }
 925  }
 926  
 927  class Google_Service_Clouddebugger_ListActiveBreakpointsResponse extends Google_Collection
 928  {
 929    protected $collection_key = 'breakpoints';
 930    protected $internal_gapi_mappings = array(
 931    );
 932    protected $breakpointsType = 'Google_Service_Clouddebugger_Breakpoint';
 933    protected $breakpointsDataType = 'array';
 934    public $nextWaitToken;
 935  
 936  
 937    public function setBreakpoints($breakpoints)
 938    {
 939      $this->breakpoints = $breakpoints;
 940    }
 941    public function getBreakpoints()
 942    {
 943      return $this->breakpoints;
 944    }
 945    public function setNextWaitToken($nextWaitToken)
 946    {
 947      $this->nextWaitToken = $nextWaitToken;
 948    }
 949    public function getNextWaitToken()
 950    {
 951      return $this->nextWaitToken;
 952    }
 953  }
 954  
 955  class Google_Service_Clouddebugger_ListBreakpointsResponse extends Google_Collection
 956  {
 957    protected $collection_key = 'breakpoints';
 958    protected $internal_gapi_mappings = array(
 959    );
 960    protected $breakpointsType = 'Google_Service_Clouddebugger_Breakpoint';
 961    protected $breakpointsDataType = 'array';
 962    public $nextWaitToken;
 963  
 964  
 965    public function setBreakpoints($breakpoints)
 966    {
 967      $this->breakpoints = $breakpoints;
 968    }
 969    public function getBreakpoints()
 970    {
 971      return $this->breakpoints;
 972    }
 973    public function setNextWaitToken($nextWaitToken)
 974    {
 975      $this->nextWaitToken = $nextWaitToken;
 976    }
 977    public function getNextWaitToken()
 978    {
 979      return $this->nextWaitToken;
 980    }
 981  }
 982  
 983  class Google_Service_Clouddebugger_ListDebuggeesResponse extends Google_Collection
 984  {
 985    protected $collection_key = 'debuggees';
 986    protected $internal_gapi_mappings = array(
 987    );
 988    protected $debuggeesType = 'Google_Service_Clouddebugger_Debuggee';
 989    protected $debuggeesDataType = 'array';
 990  
 991  
 992    public function setDebuggees($debuggees)
 993    {
 994      $this->debuggees = $debuggees;
 995    }
 996    public function getDebuggees()
 997    {
 998      return $this->debuggees;
 999    }
1000  }
1001  
1002  class Google_Service_Clouddebugger_ProjectRepoId extends Google_Model
1003  {
1004    protected $internal_gapi_mappings = array(
1005    );
1006    public $projectId;
1007    public $repoName;
1008  
1009  
1010    public function setProjectId($projectId)
1011    {
1012      $this->projectId = $projectId;
1013    }
1014    public function getProjectId()
1015    {
1016      return $this->projectId;
1017    }
1018    public function setRepoName($repoName)
1019    {
1020      $this->repoName = $repoName;
1021    }
1022    public function getRepoName()
1023    {
1024      return $this->repoName;
1025    }
1026  }
1027  
1028  class Google_Service_Clouddebugger_RegisterDebuggeeRequest extends Google_Model
1029  {
1030    protected $internal_gapi_mappings = array(
1031    );
1032    protected $debuggeeType = 'Google_Service_Clouddebugger_Debuggee';
1033    protected $debuggeeDataType = '';
1034  
1035  
1036    public function setDebuggee(Google_Service_Clouddebugger_Debuggee $debuggee)
1037    {
1038      $this->debuggee = $debuggee;
1039    }
1040    public function getDebuggee()
1041    {
1042      return $this->debuggee;
1043    }
1044  }
1045  
1046  class Google_Service_Clouddebugger_RegisterDebuggeeResponse extends Google_Model
1047  {
1048    protected $internal_gapi_mappings = array(
1049    );
1050    protected $debuggeeType = 'Google_Service_Clouddebugger_Debuggee';
1051    protected $debuggeeDataType = '';
1052  
1053  
1054    public function setDebuggee(Google_Service_Clouddebugger_Debuggee $debuggee)
1055    {
1056      $this->debuggee = $debuggee;
1057    }
1058    public function getDebuggee()
1059    {
1060      return $this->debuggee;
1061    }
1062  }
1063  
1064  class Google_Service_Clouddebugger_RepoId extends Google_Model
1065  {
1066    protected $internal_gapi_mappings = array(
1067    );
1068    protected $projectRepoIdType = 'Google_Service_Clouddebugger_ProjectRepoId';
1069    protected $projectRepoIdDataType = '';
1070    public $uid;
1071  
1072  
1073    public function setProjectRepoId(Google_Service_Clouddebugger_ProjectRepoId $projectRepoId)
1074    {
1075      $this->projectRepoId = $projectRepoId;
1076    }
1077    public function getProjectRepoId()
1078    {
1079      return $this->projectRepoId;
1080    }
1081    public function setUid($uid)
1082    {
1083      $this->uid = $uid;
1084    }
1085    public function getUid()
1086    {
1087      return $this->uid;
1088    }
1089  }
1090  
1091  class Google_Service_Clouddebugger_SetBreakpointResponse extends Google_Model
1092  {
1093    protected $internal_gapi_mappings = array(
1094    );
1095    protected $breakpointType = 'Google_Service_Clouddebugger_Breakpoint';
1096    protected $breakpointDataType = '';
1097  
1098  
1099    public function setBreakpoint(Google_Service_Clouddebugger_Breakpoint $breakpoint)
1100    {
1101      $this->breakpoint = $breakpoint;
1102    }
1103    public function getBreakpoint()
1104    {
1105      return $this->breakpoint;
1106    }
1107  }
1108  
1109  class Google_Service_Clouddebugger_SourceContext extends Google_Model
1110  {
1111    protected $internal_gapi_mappings = array(
1112    );
1113    protected $cloudRepoType = 'Google_Service_Clouddebugger_CloudRepoSourceContext';
1114    protected $cloudRepoDataType = '';
1115    protected $cloudWorkspaceType = 'Google_Service_Clouddebugger_CloudWorkspaceSourceContext';
1116    protected $cloudWorkspaceDataType = '';
1117    protected $gerritType = 'Google_Service_Clouddebugger_GerritSourceContext';
1118    protected $gerritDataType = '';
1119    protected $gitType = 'Google_Service_Clouddebugger_GitSourceContext';
1120    protected $gitDataType = '';
1121  
1122  
1123    public function setCloudRepo(Google_Service_Clouddebugger_CloudRepoSourceContext $cloudRepo)
1124    {
1125      $this->cloudRepo = $cloudRepo;
1126    }
1127    public function getCloudRepo()
1128    {
1129      return $this->cloudRepo;
1130    }
1131    public function setCloudWorkspace(Google_Service_Clouddebugger_CloudWorkspaceSourceContext $cloudWorkspace)
1132    {
1133      $this->cloudWorkspace = $cloudWorkspace;
1134    }
1135    public function getCloudWorkspace()
1136    {
1137      return $this->cloudWorkspace;
1138    }
1139    public function setGerrit(Google_Service_Clouddebugger_GerritSourceContext $gerrit)
1140    {
1141      $this->gerrit = $gerrit;
1142    }
1143    public function getGerrit()
1144    {
1145      return $this->gerrit;
1146    }
1147    public function setGit(Google_Service_Clouddebugger_GitSourceContext $git)
1148    {
1149      $this->git = $git;
1150    }
1151    public function getGit()
1152    {
1153      return $this->git;
1154    }
1155  }
1156  
1157  class Google_Service_Clouddebugger_SourceLocation extends Google_Model
1158  {
1159    protected $internal_gapi_mappings = array(
1160    );
1161    public $line;
1162    public $path;
1163  
1164  
1165    public function setLine($line)
1166    {
1167      $this->line = $line;
1168    }
1169    public function getLine()
1170    {
1171      return $this->line;
1172    }
1173    public function setPath($path)
1174    {
1175      $this->path = $path;
1176    }
1177    public function getPath()
1178    {
1179      return $this->path;
1180    }
1181  }
1182  
1183  class Google_Service_Clouddebugger_StackFrame extends Google_Collection
1184  {
1185    protected $collection_key = 'locals';
1186    protected $internal_gapi_mappings = array(
1187    );
1188    protected $argumentsType = 'Google_Service_Clouddebugger_Variable';
1189    protected $argumentsDataType = 'array';
1190    public $function;
1191    protected $localsType = 'Google_Service_Clouddebugger_Variable';
1192    protected $localsDataType = 'array';
1193    protected $locationType = 'Google_Service_Clouddebugger_SourceLocation';
1194    protected $locationDataType = '';
1195  
1196  
1197    public function setArguments($arguments)
1198    {
1199      $this->arguments = $arguments;
1200    }
1201    public function getArguments()
1202    {
1203      return $this->arguments;
1204    }
1205    public function setFunction($function)
1206    {
1207      $this->function = $function;
1208    }
1209    public function getFunction()
1210    {
1211      return $this->function;
1212    }
1213    public function setLocals($locals)
1214    {
1215      $this->locals = $locals;
1216    }
1217    public function getLocals()
1218    {
1219      return $this->locals;
1220    }
1221    public function setLocation(Google_Service_Clouddebugger_SourceLocation $location)
1222    {
1223      $this->location = $location;
1224    }
1225    public function getLocation()
1226    {
1227      return $this->location;
1228    }
1229  }
1230  
1231  class Google_Service_Clouddebugger_StatusMessage extends Google_Model
1232  {
1233    protected $internal_gapi_mappings = array(
1234    );
1235    protected $descriptionType = 'Google_Service_Clouddebugger_FormatMessage';
1236    protected $descriptionDataType = '';
1237    public $isError;
1238    public $refersTo;
1239  
1240  
1241    public function setDescription(Google_Service_Clouddebugger_FormatMessage $description)
1242    {
1243      $this->description = $description;
1244    }
1245    public function getDescription()
1246    {
1247      return $this->description;
1248    }
1249    public function setIsError($isError)
1250    {
1251      $this->isError = $isError;
1252    }
1253    public function getIsError()
1254    {
1255      return $this->isError;
1256    }
1257    public function setRefersTo($refersTo)
1258    {
1259      $this->refersTo = $refersTo;
1260    }
1261    public function getRefersTo()
1262    {
1263      return $this->refersTo;
1264    }
1265  }
1266  
1267  class Google_Service_Clouddebugger_UpdateActiveBreakpointRequest extends Google_Model
1268  {
1269    protected $internal_gapi_mappings = array(
1270    );
1271    protected $breakpointType = 'Google_Service_Clouddebugger_Breakpoint';
1272    protected $breakpointDataType = '';
1273  
1274  
1275    public function setBreakpoint(Google_Service_Clouddebugger_Breakpoint $breakpoint)
1276    {
1277      $this->breakpoint = $breakpoint;
1278    }
1279    public function getBreakpoint()
1280    {
1281      return $this->breakpoint;
1282    }
1283  }
1284  
1285  class Google_Service_Clouddebugger_UpdateActiveBreakpointResponse extends Google_Model
1286  {
1287  }
1288  
1289  class Google_Service_Clouddebugger_Variable extends Google_Collection
1290  {
1291    protected $collection_key = 'members';
1292    protected $internal_gapi_mappings = array(
1293    );
1294    protected $membersType = 'Google_Service_Clouddebugger_Variable';
1295    protected $membersDataType = 'array';
1296    public $name;
1297    protected $statusType = 'Google_Service_Clouddebugger_StatusMessage';
1298    protected $statusDataType = '';
1299    public $value;
1300    public $varTableIndex;
1301  
1302  
1303    public function setMembers($members)
1304    {
1305      $this->members = $members;
1306    }
1307    public function getMembers()
1308    {
1309      return $this->members;
1310    }
1311    public function setName($name)
1312    {
1313      $this->name = $name;
1314    }
1315    public function getName()
1316    {
1317      return $this->name;
1318    }
1319    public function setStatus(Google_Service_Clouddebugger_StatusMessage $status)
1320    {
1321      $this->status = $status;
1322    }
1323    public function getStatus()
1324    {
1325      return $this->status;
1326    }
1327    public function setValue($value)
1328    {
1329      $this->value = $value;
1330    }
1331    public function getValue()
1332    {
1333      return $this->value;
1334    }
1335    public function setVarTableIndex($varTableIndex)
1336    {
1337      $this->varTableIndex = $varTableIndex;
1338    }
1339    public function getVarTableIndex()
1340    {
1341      return $this->varTableIndex;
1342    }
1343  }