vendor/doctrine/couchdb/lib/Doctrine/CouchDB/CouchDBClient.php

   1 <?php
   2 /*
   3  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   4  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   5  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   6  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   7  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   8  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   9  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14  *
  15  * This software consists of voluntary contributions made by many individuals
  16  * and is licensed under the MIT license. For more information, see
  17  * <http://www.doctrine-project.org>.
  18  */
  19
  20 namespace Doctrine\CouchDB;
  21
  22 use Doctrine\CouchDB\HTTP\Client;
  23 use Doctrine\CouchDB\HTTP\Response;
  24 use Doctrine\CouchDB\HTTP\HTTPException;
  25 use Doctrine\CouchDB\HTTP\MultipartParserAndSender;
  26 use Doctrine\CouchDB\HTTP\StreamClient;
  27 use Doctrine\CouchDB\Utils\BulkUpdater;
  28 use Doctrine\CouchDB\View\DesignDocument;
  29
  30 /**
  31  * CouchDB client class
  32  *
  33  * @license     http://www.opensource.org/licenses/mit-license.php MIT
  34  * @link        www.doctrine-project.com
  35  * @since       1.0
  36  * @author      Benjamin Eberlei <kontakt@beberlei.de>
  37  * @author      Lukas Kahwe Smith <smith@pooteeweet.org>
  38  */
  39 class CouchDBClient
  40 {
  41     /** string \ufff0 */
  42     const COLLATION_END = "\xEF\xBF\xB0";
  43
  44     /**
  45      * Name of the CouchDB database
  46      *
  47      * @string
  48      */
  49     protected $databaseName;
  50
  51     /**
  52      * The underlying HTTP Connection of the used DocumentManager.
  53      *
  54      * @var Client
  55      */
  56     private $httpClient;
  57
  58     /**
  59      * CouchDB Version
  60      *
  61      * @var string
  62      */
  63     private $version = null;
  64
  65     static private $clients = array(
  66         'socket' => 'Doctrine\CouchDB\HTTP\SocketClient',
  67         'stream' => 'Doctrine\CouchDB\HTTP\StreamClient',
  68     );
  69
  70     /**
  71      * Factory method for CouchDBClients
  72      *
  73      * @param array $options
  74      * @return CouchDBClient
  75      * @throws \InvalidArgumentException
  76      */
  77     static public function create(array $options)
  78     {
  79         if (isset($options['url'])) {
  80             $urlParts = parse_url($options['url']);
  81             $urlOptions = ['user' => 'user', 'pass' => 'password', 'host' => 'host', 'path' => 'dbname', 'port' => 'port'];
  82             foreach ($urlParts as $part => $value) {
  83                 switch($part) {
  84                     case 'host':
  85                     case 'user':
  86                     case 'port':
  87                         $options[$part] = $value;
  88                         break;
  89
  90                     case 'path':
  91                         $path = explode('/', $value);
  92                         $options['dbname'] = array_pop($path);
  93                         $options['path'] = trim(implode('/', $path), '/');
  94                         break;
  95
  96                     case 'pass':
  97                         $options['password'] = $value;
  98                         break;
  99
 100                     case 'scheme':
 101                         $options['ssl'] = ($value === 'https');
 102                         break;
 103
 104                     default:
 105                         break;
 106                 }
 107             }
 108         }
 109
 110         if (!isset($options['dbname'])) {
 111             throw new \InvalidArgumentException("'dbname' is a required option to create a CouchDBClient");
 112         }
 113
 114         $defaults = array(
 115             'type' => 'socket',
 116             'host' => 'localhost',
 117             'port' => 5984,
 118             'user' => null,
 119             'password' => null,
 120             'ip' => null,
 121             'ssl' => false,
 122             'path' => null,
 123             'logging' => false,
 124             'timeout' => 0.01,
 125         );
 126         $options = array_merge($defaults, $options);
 127
 128         if (!isset(self::$clients[$options['type']])) {
 129             throw new \InvalidArgumentException(sprintf('There is no client implementation registered for %s, valid options are: %s',
 130                 $options['type'], implode(", ", array_keys(self::$clients))
 131             ));
 132         }
 133         $connectionClass = self::$clients[$options['type']];
 134         $connection = new $connectionClass(
 135             $options['host'],
 136             $options['port'],
 137             $options['user'],
 138             $options['password'],
 139             $options['ip'],
 140             $options['ssl'],
 141             $options['path'],
 142             $options['timeout']
 143         );
 144         if ($options['logging'] === true) {
 145             $connection = new HTTP\LoggingClient($connection);
 146         }
 147         return new static($connection, $options['dbname']);
 148     }
 149
 150     /**
 151      * @param Client $client
 152      * @param string $databaseName
 153      */
 154     public function __construct(Client $client, $databaseName)
 155     {
 156         $this->httpClient = $client;
 157         $this->databaseName = $databaseName;
 158     }
 159
 160     public function setHttpClient(Client $client)
 161     {
 162         $this->httpClient = $client;
 163     }
 164
 165     /**
 166      * @return Client
 167      */
 168     public function getHttpClient()
 169     {
 170         return $this->httpClient;
 171     }
 172
 173     public function getDatabase()
 174     {
 175         return $this->databaseName;
 176     }
 177
 178     /**
 179      * Let CouchDB generate an array of UUIDs.
 180      *
 181      * @param  int $count
 182      * @return array
 183      * @throws CouchDBException
 184      */
 185     public function getUuids($count = 1)
 186     {
 187         $count = (int)$count;
 188         $response = $this->httpClient->request('GET', '/_uuids?count=' . $count);
 189
 190         if ($response->status != 200) {
 191             throw new CouchDBException("Could not retrieve UUIDs from CouchDB.");
 192         }
 193
 194         return $response->body['uuids'];
 195     }
 196
 197     /**
 198      * Find a document by ID and return the HTTP response.
 199      *
 200      * @param string $id
 201      * @return HTTP\Response
 202      */
 203     public function findDocument($id)
 204     {
 205         $documentPath = '/' . $this->databaseName . '/' . urlencode($id);
 206         return $this->httpClient->request('GET', $documentPath);
 207     }
 208
 209     /**
 210      * Find documents of all or the specified revisions.
 211      *
 212      * If $revisions is an array containing the revisions to be fetched, only
 213      * the documents of those revisions are fetched. Else document of all
 214      * leaf revisions are fetched.
 215      *
 216      * @param string $docId
 217      * @param mixed $revisions
 218      * @return HTTP\Response
 219      */
 220     public function findRevisions($docId, $revisions = null)
 221     {
 222         $path = '/' . $this->databaseName . '/' . urlencode($docId);
 223         if (is_array($revisions)) {
 224             // Fetch documents of only the specified leaf revisions.
 225             $path .= '?open_revs=' . json_encode($revisions);
 226         } else {
 227             // Fetch documents of all leaf revisions.
 228             $path .= '?open_revs=all';
 229         }
 230         // Set the Accept header to application/json to get a JSON array in the
 231         // response's body. Without this the response is multipart/mixed stream.
 232         return $this->httpClient->request(
 233             'GET',
 234             $path,
 235             null,
 236             false,
 237             array('Accept' => 'application/json')
 238         );
 239     }
 240
 241     /**
 242      * Find many documents by passing their ids and return the HTTP response.
 243      *
 244      * @param array $ids
 245      * @param null $limit
 246      * @param null $offset
 247      * @return HTTP\Response
 248      */
 249     public function findDocuments(array $ids, $limit = null, $offset = null)
 250     {
 251         $allDocsPath = '/' . $this->databaseName . '/_all_docs?include_docs=true';
 252         if ($limit) {
 253             $allDocsPath .= '&limit=' . (int)$limit;
 254         }
 255         if ($offset) {
 256             $allDocsPath .= '&skip=' . (int)$offset;
 257         }
 258
 259         return $this->httpClient->request('POST', $allDocsPath, json_encode(
 260             array('keys' => array_values($ids)))
 261         );
 262     }
 263
 264     /**
 265      * Get all documents
 266      *
 267      * @param int|null $limit
 268      * @param string|null $startKey
 269      * @param string|null $endKey
 270      * @param int|null $skip
 271      * @param bool $descending
 272      * @return HTTP\Response
 273      */
 274     public function allDocs($limit = null, $startKey = null, $endKey = null, $skip = null, $descending = false)
 275     {
 276         $allDocsPath = '/' . $this->databaseName . '/_all_docs?include_docs=true';
 277         if ($limit) {
 278             $allDocsPath .= '&limit=' . (int)$limit;
 279         }
 280         if ($startKey) {
 281             $allDocsPath .= '&startkey="' . (string)$startKey.'"';
 282         }
 283         if (!is_null($endKey)) {
 284             $allDocsPath .= '&endkey="' . (string)$endKey.'"';
 285         }
 286         if (!is_null($skip) && (int)$skip > 0) {
 287             $allDocsPath .= '&skip=' . (int)$skip;
 288         }
 289         if (!is_null($descending) && (bool)$descending === true) {
 290             $allDocsPath .= '&descending=true';
 291         }
 292         return $this->httpClient->request('GET', $allDocsPath);
 293     }
 294
 295     /**
 296      * Get the current version of CouchDB.
 297      *
 298      * @throws HTTPException
 299      * @return string
 300      */
 301     public function getVersion()
 302     {
 303         if ($this->version === null) {
 304             $response = $this->httpClient->request('GET', '/');
 305             if ($response->status != 200) {
 306                 throw HTTPException::fromResponse('/', $response);
 307             }
 308
 309             $this->version = $response->body['version'];
 310         }
 311         return $this->version;
 312     }
 313
 314     /**
 315      * Get all databases
 316      *
 317      * @throws HTTPException
 318      * @return array
 319      */
 320     public function getAllDatabases()
 321     {
 322         $response = $this->httpClient->request('GET', '/_all_dbs');
 323         if ($response->status != 200) {
 324             throw HTTPException::fromResponse('/_all_dbs', $response);
 325         }
 326
 327         return $response->body;
 328     }
 329
 330     /**
 331      * Create a new database
 332      *
 333      * @throws HTTPException
 334      * @param string $name
 335      * @return void
 336      */
 337     public function createDatabase($name)
 338     {
 339         $response = $this->httpClient->request('PUT', '/' . urlencode($name));
 340
 341         if ($response->status != 201) {
 342             throw HTTPException::fromResponse('/' . urlencode($name), $response);
 343         }
 344     }
 345
 346     /**
 347      * Drop a database
 348      *
 349      * @throws HTTPException
 350      * @param string $name
 351      * @return void
 352      */
 353     public function deleteDatabase($name)
 354     {
 355         $response = $this->httpClient->request('DELETE', '/' . urlencode($name));
 356
 357         if ($response->status != 200 && $response->status != 404) {
 358             throw HTTPException::fromResponse('/' . urlencode($name), $response);
 359         }
 360     }
 361
 362     /**
 363      * Get Information about a database.
 364      *
 365      * @param  string $name
 366      * @return array
 367      * @throws HTTPException
 368      */
 369     public function getDatabaseInfo($name = null)
 370     {
 371         $response = $this->httpClient->request('GET', '/' . ($name ? urlencode($name) : $this->databaseName));
 372
 373         if ($response->status != 200) {
 374             throw HTTPException::fromResponse('/' . urlencode($name), $response);
 375         }
 376
 377         return $response->body;
 378     }
 379
 380     /**
 381      * Get changes.
 382      *
 383      * @param array $params
 384      * @return array
 385      * @throws HTTPException
 386      */
 387     public function getChanges(array $params = array())
 388     {
 389         $path = '/' . $this->databaseName . '/_changes';
 390
 391         $method = ((!isset($params['doc_ids']) || $params['doc_ids'] == null) ? "GET" : "POST");
 392         $response = '';
 393
 394         if ($method == "GET") {
 395
 396             foreach ($params as $key => $value) {
 397                 if (isset($params[$key]) === true && is_bool($value) === true) {
 398                     $params[$key] = ($value) ? 'true' : 'false';
 399                 }
 400             }
 401             if (count($params) > 0) {
 402                 $query = http_build_query($params);
 403                 $path = $path.'?'.$query;
 404             }
 405             $response = $this->httpClient->request('GET', $path);
 406
 407         } else {
 408             $path .= '?filter=_doc_ids';
 409             $response = $this->httpClient->request('POST', $path, json_encode($params));
 410         }
 411         if ($response->status != 200) {
 412             throw HTTPException::fromResponse($path, $response);
 413         }
 414
 415         return $response->body;
 416     }
 417
 418     /**
 419      * Create a bulk updater instance.
 420      *
 421      * @return BulkUpdater
 422      */
 423     public function createBulkUpdater()
 424     {
 425         return new BulkUpdater($this->httpClient, $this->databaseName);
 426     }
 427
 428     /**
 429      * Execute a POST request against CouchDB inserting a new document, leaving the server to generate a uuid.
 430      *
 431      * @param  array $data
 432      * @return array<id, rev>
 433      * @throws HTTPException
 434      */
 435     public function postDocument(array $data)
 436     {
 437         $path = '/' . $this->databaseName;
 438         $response = $this->httpClient->request('POST', $path, json_encode($data));
 439
 440         if ($response->status != 201) {
 441             throw HTTPException::fromResponse($path, $response);
 442         }
 443
 444         return array($response->body['id'], $response->body['rev']);
 445     }
 446
 447     /**
 448      * Execute a PUT request against CouchDB inserting or updating a document.
 449      *
 450      * @param array $data
 451      * @param string $id
 452      * @param string|null $rev
 453      * @return array<id, rev>
 454      * @throws HTTPException
 455      */
 456     public function putDocument($data, $id, $rev = null)
 457     {
 458         $data['_id'] = $id;
 459         if ($rev) {
 460             $data['_rev'] = $rev;
 461         }
 462
 463         $path = '/' . $this->databaseName . '/' . urlencode($id);
 464         $response = $this->httpClient->request('PUT', $path, json_encode($data));
 465
 466         if ($response->status != 201) {
 467             throw HTTPException::fromResponse($path, $response);
 468         }
 469
 470         return array($response->body['id'], $response->body['rev']);
 471     }
 472
 473     /**
 474      * Delete a document.
 475      *
 476      * @param  string $id
 477      * @param  string $rev
 478      * @return void
 479      * @throws HTTPException
 480      */
 481     public function deleteDocument($id, $rev)
 482     {
 483         $path = '/' . $this->databaseName . '/' . urlencode($id) . '?rev=' . $rev;
 484         $response = $this->httpClient->request('DELETE', $path);
 485
 486         if ($response->status != 200) {
 487             throw HTTPException::fromResponse($path, $response);
 488         }
 489     }
 490
 491     /**
 492      * @param string $designDocName
 493      * @param string $viewName
 494      * @param DesignDocument $designDoc
 495      * @return View\Query
 496      */
 497     public function createViewQuery($designDocName, $viewName, DesignDocument $designDoc = null)
 498     {
 499         return new View\Query($this->httpClient, $this->databaseName, $designDocName, $viewName, $designDoc);
 500     }
 501
 502     /**
 503      * Create or update a design document from the given in memory definition.
 504      *
 505      * @param string $designDocName
 506      * @param DesignDocument $designDoc
 507      * @return HTTP\Response
 508      */
 509     public function createDesignDocument($designDocName, DesignDocument $designDoc)
 510     {
 511         $data        = $designDoc->getData();
 512         $data['_id'] = '_design/' . $designDocName;
 513
 514         $documentPath = '/' . $this->databaseName . '/' . $data['_id'];
 515         $response     = $this->httpClient->request( 'GET', $documentPath );
 516
 517         if ($response->status == 200) {
 518             $docData = $response->body;
 519             $data['_rev'] = $docData['_rev'];
 520         }
 521
 522         return $this->httpClient->request(
 523             "PUT",
 524             sprintf("/%s/_design/%s", $this->databaseName, $designDocName),
 525             json_encode($data)
 526         );
 527     }
 528
 529     /**
 530      * GET /db/_compact
 531      *
 532      * Return array of data about compaction status.
 533      *
 534      * @return array
 535      * @throws HTTPException
 536      */
 537     public function getCompactInfo()
 538     {
 539         $path = sprintf('/%s/_compact', $this->databaseName);
 540         $response = $this->httpClient->request('GET', $path);
 541         if ($response->status >= 400) {
 542             throw HTTPException::fromResponse($path, $response);
 543         }
 544         return $response->body;
 545     }
 546
 547     /**
 548      * POST /db/_compact
 549      *
 550      * @return array
 551      * @throws HTTPException
 552      */
 553     public function compactDatabase()
 554     {
 555         $path = sprintf('/%s/_compact', $this->databaseName);
 556         $response = $this->httpClient->request('POST', $path);
 557         if ($response->status >= 400) {
 558             throw HTTPException::fromResponse($path, $response);
 559         }
 560         return $response->body;
 561     }
 562
 563     /**
 564      * POST /db/_compact/designDoc
 565      *
 566      * @param string $designDoc
 567      * @return array
 568      * @throws HTTPException
 569      */
 570     public function compactView($designDoc)
 571     {
 572         $path = sprintf('/%s/_compact/%s', $this->databaseName, $designDoc);
 573         $response = $this->httpClient->request('POST', $path);
 574         if ($response->status >= 400) {
 575             throw HTTPException::fromResponse($path, $response);
 576         }
 577         return $response->body;
 578     }
 579
 580     /**
 581      * POST /db/_view_cleanup
 582      *
 583      * @return array
 584      * @throws HTTPException
 585      */
 586     public function viewCleanup()
 587     {
 588         $path = sprintf('/%s/_view_cleanup', $this->databaseName);
 589         $response = $this->httpClient->request('POST', $path);
 590         if ($response->status >= 400) {
 591             throw HTTPException::fromResponse($path, $response);
 592         }
 593         return $response->body;
 594     }
 595
 596     /**
 597      * POST /db/_replicate
 598      *
 599      * @param string $source
 600      * @param string $target
 601      * @param bool|null $cancel
 602      * @param bool|null $continuous
 603      * @param string|null $filter
 604      * @param array|null $ids
 605      * @param string|null $proxy
 606      * @return array
 607      * @throws HTTPException
 608      */
 609     public function replicate($source, $target, $cancel = null, $continuous = null, $filter = null, array $ids = null, $proxy = null)
 610     {
 611         $params = array('target' => $target, 'source' => $source);
 612         if ($cancel !== null) {
 613             $params['cancel'] = (bool)$cancel;
 614         }
 615         if ($continuous !== null) {
 616             $params['continuous'] = (bool)$continuous;
 617         }
 618         if ($filter !== null) {
 619             $params['filter'] = $filter;
 620         }
 621         if ($ids !== null) {
 622             $params['doc_ids'] = $ids;
 623         }
 624         if ($proxy !== null) {
 625             $params['proxy'] = $proxy;
 626         }
 627         $path = '/_replicate';
 628         $response = $this->httpClient->request('POST', $path, json_encode($params));
 629         if ($response->status >= 400) {
 630             throw HTTPException::fromResponse($path, $response);
 631         }
 632         return $response->body;
 633     }
 634
 635     /**
 636      * GET /_active_tasks
 637      *
 638      * @return array
 639      * @throws HTTPException
 640      */
 641     public function getActiveTasks()
 642     {
 643         $response = $this->httpClient->request('GET', '/_active_tasks');
 644         if ($response->status != 200) {
 645             throw HTTPException::fromResponse('/_active_tasks', $response);
 646         }
 647         return $response->body;
 648     }
 649
 650     /**
 651      * Get revision difference.
 652      *
 653      * @param  array $data
 654      * @return array
 655      * @throws HTTPException
 656      */
 657     public function getRevisionDifference($data)
 658     {
 659         $path = '/' . $this->databaseName . '/_revs_diff';
 660         $response = $this->httpClient->request('POST', $path, json_encode($data));
 661         if ($response->status != 200) {
 662             throw HTTPException::fromResponse($path, $response);
 663         }
 664         return $response->body;
 665     }
 666
 667     /**
 668      * Transfer missing revisions to the target. The Content-Type of response
 669      * from the source should be multipart/mixed.
 670      *
 671      * @param string $docId
 672      * @param array $missingRevs
 673      * @param CouchDBClient $target
 674      * @return array|HTTP\ErrorResponse|string
 675      * @throws HTTPException
 676      */
 677     public function transferChangedDocuments($docId, $missingRevs, CouchDBClient $target)
 678     {
 679         $path = '/' . $this->getDatabase() . '/' . $docId;
 680         $params = array('revs' => true, 'latest' => true, 'open_revs' => json_encode($missingRevs));
 681         $query = http_build_query($params);
 682         $path .= '?' . $query;
 683
 684         $targetPath = '/' . $target->getDatabase() . '/' . $docId . '?new_edits=false';
 685
 686         $mutltipartHandler = new MultipartParserAndSender($this->getHttpClient(), $target->getHttpClient());
 687         return $mutltipartHandler->request(
 688             'GET',
 689             $path,
 690             $targetPath,
 691             null,
 692             array('Accept' => 'multipart/mixed')
 693         );
 694
 695     }
 696
 697     /**
 698      * Get changes as a stream.
 699      *
 700      * This method similar to the getChanges() method. But instead of returning
 701      * the set of changes, it returns the connection stream from which the response
 702      * can be read line by line. This is useful when you want to continuously get changes
 703      * as they occur. Filtered changes feed is not supported by this method.
 704      *
 705      * @param array $params
 706      * @param bool $raw
 707      * @return resource
 708      * @throws HTTPException
 709      */
 710     public function getChangesAsStream(array $params = array())
 711     {
 712         // Set feed to continuous.
 713         if (!isset($params['feed']) || $params['feed'] != 'continuous') {
 714             $params['feed'] = 'continuous';
 715         }
 716         $path = '/' . $this->databaseName . '/_changes';
 717         $connectionOptions = $this->getHttpClient()->getOptions();
 718         $streamClient = new StreamClient(
 719             $connectionOptions['host'],
 720             $connectionOptions['port'],
 721             $connectionOptions['username'],
 722             $connectionOptions['password'],
 723             $connectionOptions['ip'],
 724             $connectionOptions['ssl'],
 725             $connectionOptions['path']
 726         );
 727
 728         foreach ($params as $key => $value) {
 729             if (isset($params[$key]) === true && is_bool($value) === true) {
 730                 $params[$key] = ($value) ? 'true' : 'false';
 731             }
 732         }
 733         if (count($params) > 0) {
 734             $query = http_build_query($params);
 735             $path = $path . '?' . $query;
 736         }
 737         $stream = $streamClient->getConnection('GET', $path, null);
 738
 739         $headers = $streamClient->getStreamHeaders($stream);
 740         if (empty($headers['status'])) {
 741             throw HTTPException::readFailure(
 742                 $connectionOptions['ip'],
 743                 $connectionOptions['port'],
 744                 'Received an empty response or not status code',
 745                 0
 746             );
 747         } elseif ($headers['status'] != 200) {
 748             $body = '';
 749             while (!feof($stream)) {
 750                 $body .= fgets($stream);
 751             }
 752             throw HTTPException::fromResponse($path, new Response($headers['status'], $headers, $body));
 753         }
 754         // Everything seems okay. Return the connection resource.
 755         return $stream;
 756
 757     }
 758
 759     /**
 760      * Commit any recent changes to the specified database to disk.
 761      *
 762      * @return array
 763      * @throws HTTPException
 764      */
 765     public function ensureFullCommit()
 766     {
 767         $path = '/' . $this->databaseName . '/_ensure_full_commit';
 768         $response = $this->httpClient->request('POST', $path);
 769         if ($response->status != 201) {
 770             throw HTTPException::fromResponse($path, $response);
 771         }
 772         return $response->body;
 773     }
 774 }